nextcloud / fulltextsearch_elasticsearch

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/Tags/RemovedTag.php

Indentation +39 added lines, -39 removed lines

@@ -10,43 +10,43 @@
 
 class RemovedTag extends BaseTag
 {
-    private const REGEX_VECTOR = '(?:\d\S*|[^\s\:]+\:\s*\$[^\$]+\$)';
-    private $version;
-
-    public function __construct(?string $version = null, Description $description = null)
-    {
-        $this->version = $version;
-        $this->name = 'removed';
-        $this->description = $description;
-    }
-
-    public static function create(?string $body, ?DescriptionFactory $descriptionFactory = null, ?Context $context = null): RemovedTag
-    {
-        if (empty($body)) {
-            return new self();
-        }
-
-        $matches = [];
-        if ($descriptionFactory !== null) {
-            if (!preg_match('/^(' . self::REGEX_VECTOR . ')\s*(.+)?$/sux', $body, $matches)) {
-                return new self(null, $descriptionFactory->create($body, $context));
-            }
-
-            return new self(
-                $matches[1],
-                $descriptionFactory->create($matches[2] ?? '', $context)
-            );
-        }
-        return new self();
-    }
-
-    public function getVersion(): ?string
-    {
-        return $this->version;
-    }
-
-    public function __toString(): string
-    {
-        return "PhpStorm internal '@removed' tag";
-    }
+	private const REGEX_VECTOR = '(?:\d\S*|[^\s\:]+\:\s*\$[^\$]+\$)';
+	private $version;
+
+	public function __construct(?string $version = null, Description $description = null)
+	{
+		$this->version = $version;
+		$this->name = 'removed';
+		$this->description = $description;
+	}
+
+	public static function create(?string $body, ?DescriptionFactory $descriptionFactory = null, ?Context $context = null): RemovedTag
+	{
+		if (empty($body)) {
+			return new self();
+		}
+
+		$matches = [];
+		if ($descriptionFactory !== null) {
+			if (!preg_match('/^(' . self::REGEX_VECTOR . ')\s*(.+)?$/sux', $body, $matches)) {
+				return new self(null, $descriptionFactory->create($body, $context));
+			}
+
+			return new self(
+				$matches[1],
+				$descriptionFactory->create($matches[2] ?? '', $context)
+			);
+		}
+		return new self();
+	}
+
+	public function getVersion(): ?string
+	{
+		return $this->version;
+	}
+
+	public function __toString(): string
+	{
+		return "PhpStorm internal '@removed' tag";
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
 
         $matches = [];
         if ($descriptionFactory !== null) {
-            if (!preg_match('/^(' . self::REGEX_VECTOR . ')\s*(.+)?$/sux', $body, $matches)) {
+            if (!preg_match('/^('.self::REGEX_VECTOR.')\s*(.+)?$/sux', $body, $matches)) {
                 return new self(null, $descriptionFactory->create($body, $context));
             }
 

Braces +1 added lines, -2 removed lines

@@ -8,8 +8,7 @@
 use phpDocumentor\Reflection\DocBlock\Tags\BaseTag;
 use phpDocumentor\Reflection\Types\Context;
 
-class RemovedTag extends BaseTag
-{
+class RemovedTag extends BaseTag {
     private const REGEX_VECTOR = '(?:\d\S*|[^\s\:]+\:\s*\$[^\$]+\$)';
     private $version;
 

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/BasePHPElement.php

Indentation +201 added lines, -201 removed lines

@@ -29,205 +29,205 @@
 
 abstract class BasePHPElement
 {
-    use PHPDocElement;
-
-    /** @var string|null */
-    public $name;
-    public $stubBelongsToCore = false;
-    /** @var Exception|null */
-    public $parseError;
-    public $mutedProblems = [];
-    public $availableVersionsRangeFromAttribute = [];
-    /** @var string|null */
-    public $sourceFilePath;
-    /** @var bool */
-    public $duplicateOtherElement = false;
-
-    /**
-     * @param Reflector $reflectionObject
-     * @return static
-     */
-    abstract public function readObjectFromReflection($reflectionObject);
-
-    /**
-     * @param Node $node
-     * @return static
-     */
-    abstract public function readObjectFromStubNode($node);
-
-    /**
-     * @param stdClass|array $jsonData
-     */
-    abstract public function readMutedProblems($jsonData): void;
-
-    public static function getFQN(Node $node): string
-    {
-        $fqn = '';
-        if (!property_exists($node, 'namespacedName') || $node->namespacedName === null) {
-            if (property_exists($node, 'name')) {
-                $fqn = $node->name->parts[0];
-            } else {
-                foreach ($node->parts as $part) {
-                    $fqn .= "$part\\";
-                }
-            }
-        } else {
-            /** @var string $part */
-            foreach ($node->namespacedName->parts as $part) {
-                $fqn .= "$part\\";
-            }
-        }
-        return rtrim($fqn, "\\");
-    }
-
-    protected static function getReflectionTypeAsArray(?ReflectionType $type): array
-    {
-        $reflectionTypes = [];
-        if ($type instanceof ReflectionNamedType) {
-            $type->allowsNull() && $type->getName() !== 'mixed' ?
-                array_push($reflectionTypes, '?' . $type->getName()) : array_push($reflectionTypes, $type->getName());
-        }
-        if ($type instanceof ReflectionUnionType) {
-            foreach ($type->getTypes() as $namedType) {
-                $reflectionTypes[] = $namedType->getName();
-            }
-        }
-        return $reflectionTypes;
-    }
-
-    /**
-     * @param Name|Identifier|NullableType|string|UnionType|null|Type $type
-     */
-    protected static function convertParsedTypeToArray($type): array
-    {
-        $types = [];
-        if ($type !== null) {
-            if ($type instanceof UnionType) {
-                foreach ($type->types as $namedType) {
-                    $types[] = self::getTypeNameFromNode($namedType);
-                }
-            } elseif ($type instanceof Type) {
-                array_push($types, ...explode('|', (string)$type));
-            } else {
-                $types[] = self::getTypeNameFromNode($type);
-            }
-        }
-        return $types;
-    }
-
-    /**
-     * @param Name|Identifier|NullableType|string $type
-     */
-    protected static function getTypeNameFromNode($type): string
-    {
-        $nullable = false;
-        $typeName = '';
-        if ($type instanceof NullableType) {
-            $type = $type->type;
-            $nullable = true;
-        }
-        if (empty($type->name)) {
-            if (!empty($type->parts)) {
-                $typeName = $nullable ? '?' . implode('\\', $type->parts) : implode('\\', $type->parts);
-            }
-        } else {
-            $typeName = $nullable ? '?' . $type->name : $type->name;
-        }
-        return $typeName;
-    }
-
-    /**
-     * @param AttributeGroup[] $attrGroups
-     * @return string[]
-     */
-    protected static function findTypesFromAttribute(array $attrGroups): array
-    {
-        foreach ($attrGroups as $attrGroup) {
-            foreach ($attrGroup->attrs as $attr) {
-                if ($attr->name->toString() === LanguageLevelTypeAware::class) {
-                    $types = [];
-                    $versionTypesMap = $attr->args[0]->value->items;
-                    foreach ($versionTypesMap as $item) {
-                        $firstVersionWithType = $item->key->value;
-                        foreach (new PhpVersions() as $version) {
-                            if ($version >= (float)$firstVersionWithType) {
-                                $types[number_format($version, 1)] =
-                                    explode('|', preg_replace('/\w+\[]/', 'array', $item->value->value));
-                            }
-                        }
-                    }
-                    $types[$attr->args[1]->name->name] = explode('|', preg_replace('/\w+\[]/', 'array', $attr->args[1]->value->value));
-                    return $types;
-                }
-            }
-        }
-        return [];
-    }
-
-    /**
-     * @param AttributeGroup[] $attrGroups
-     * @return array
-     */
-    protected static function findAvailableVersionsRangeFromAttribute(array $attrGroups): array
-    {
-        $versionRange = [];
-        foreach ($attrGroups as $attrGroup) {
-            foreach ($attrGroup->attrs as $attr) {
-                if ($attr->name->toString() === PhpStormStubsElementAvailable::class) {
-                    if (count($attr->args) === 2) {
-                        foreach ($attr->args as $arg) {
-                            $versionRange[$arg->name->name] = (float)$arg->value->value;
-                        }
-                    } else {
-                        $arg = $attr->args[0]->value;
-                        if ($arg instanceof Array_) {
-                            $value = $arg->items[0]->value;
-                            if ($value instanceof String_) {
-                                return ['from' => (float)$value->value];
-                            }
-                        } else {
-                            $rangeName = $attr->args[0]->name;
-                            return $rangeName === null || $rangeName->name === 'from' ?
-                                ['from' => (float)$arg->value, 'to' => PhpVersions::getLatest()] :
-                                ['from' => PhpVersions::getFirst(), 'to' => (float)$arg->value];
-                        }
-                    }
-                }
-            }
-        }
-        return $versionRange;
-    }
-
-    protected static function hasTentativeTypeAttribute(array $attrGroups): bool
-    {
-        foreach ($attrGroups as $attrGroup) {
-            foreach ($attrGroup->attrs as $attr) {
-                if ($attr->name->toString() === TentativeType::class) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public function hasMutedProblem(int $stubProblemType): bool
-    {
-        if (array_key_exists($stubProblemType, $this->mutedProblems)) {
-            if (in_array('ALL', $this->mutedProblems[$stubProblemType], true) ||
-                in_array((float)getenv('PHP_VERSION'), $this->mutedProblems[$stubProblemType], true)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @param BasePHPElement $element
-     * @return bool
-     * @throws RuntimeException
-     */
-    public static function entitySuitsCurrentPhpVersion(BasePHPElement $element): bool
-    {
-        return in_array((float)getenv('PHP_VERSION'), ParserUtils::getAvailableInVersions($element), true);
-    }
+	use PHPDocElement;
+
+	/** @var string|null */
+	public $name;
+	public $stubBelongsToCore = false;
+	/** @var Exception|null */
+	public $parseError;
+	public $mutedProblems = [];
+	public $availableVersionsRangeFromAttribute = [];
+	/** @var string|null */
+	public $sourceFilePath;
+	/** @var bool */
+	public $duplicateOtherElement = false;
+
+	/**
+	 * @param Reflector $reflectionObject
+	 * @return static
+	 */
+	abstract public function readObjectFromReflection($reflectionObject);
+
+	/**
+	 * @param Node $node
+	 * @return static
+	 */
+	abstract public function readObjectFromStubNode($node);
+
+	/**
+	 * @param stdClass|array $jsonData
+	 */
+	abstract public function readMutedProblems($jsonData): void;
+
+	public static function getFQN(Node $node): string
+	{
+		$fqn = '';
+		if (!property_exists($node, 'namespacedName') || $node->namespacedName === null) {
+			if (property_exists($node, 'name')) {
+				$fqn = $node->name->parts[0];
+			} else {
+				foreach ($node->parts as $part) {
+					$fqn .= "$part\\";
+				}
+			}
+		} else {
+			/** @var string $part */
+			foreach ($node->namespacedName->parts as $part) {
+				$fqn .= "$part\\";
+			}
+		}
+		return rtrim($fqn, "\\");
+	}
+
+	protected static function getReflectionTypeAsArray(?ReflectionType $type): array
+	{
+		$reflectionTypes = [];
+		if ($type instanceof ReflectionNamedType) {
+			$type->allowsNull() && $type->getName() !== 'mixed' ?
+				array_push($reflectionTypes, '?' . $type->getName()) : array_push($reflectionTypes, $type->getName());
+		}
+		if ($type instanceof ReflectionUnionType) {
+			foreach ($type->getTypes() as $namedType) {
+				$reflectionTypes[] = $namedType->getName();
+			}
+		}
+		return $reflectionTypes;
+	}
+
+	/**
+	 * @param Name|Identifier|NullableType|string|UnionType|null|Type $type
+	 */
+	protected static function convertParsedTypeToArray($type): array
+	{
+		$types = [];
+		if ($type !== null) {
+			if ($type instanceof UnionType) {
+				foreach ($type->types as $namedType) {
+					$types[] = self::getTypeNameFromNode($namedType);
+				}
+			} elseif ($type instanceof Type) {
+				array_push($types, ...explode('|', (string)$type));
+			} else {
+				$types[] = self::getTypeNameFromNode($type);
+			}
+		}
+		return $types;
+	}
+
+	/**
+	 * @param Name|Identifier|NullableType|string $type
+	 */
+	protected static function getTypeNameFromNode($type): string
+	{
+		$nullable = false;
+		$typeName = '';
+		if ($type instanceof NullableType) {
+			$type = $type->type;
+			$nullable = true;
+		}
+		if (empty($type->name)) {
+			if (!empty($type->parts)) {
+				$typeName = $nullable ? '?' . implode('\\', $type->parts) : implode('\\', $type->parts);
+			}
+		} else {
+			$typeName = $nullable ? '?' . $type->name : $type->name;
+		}
+		return $typeName;
+	}
+
+	/**
+	 * @param AttributeGroup[] $attrGroups
+	 * @return string[]
+	 */
+	protected static function findTypesFromAttribute(array $attrGroups): array
+	{
+		foreach ($attrGroups as $attrGroup) {
+			foreach ($attrGroup->attrs as $attr) {
+				if ($attr->name->toString() === LanguageLevelTypeAware::class) {
+					$types = [];
+					$versionTypesMap = $attr->args[0]->value->items;
+					foreach ($versionTypesMap as $item) {
+						$firstVersionWithType = $item->key->value;
+						foreach (new PhpVersions() as $version) {
+							if ($version >= (float)$firstVersionWithType) {
+								$types[number_format($version, 1)] =
+									explode('|', preg_replace('/\w+\[]/', 'array', $item->value->value));
+							}
+						}
+					}
+					$types[$attr->args[1]->name->name] = explode('|', preg_replace('/\w+\[]/', 'array', $attr->args[1]->value->value));
+					return $types;
+				}
+			}
+		}
+		return [];
+	}
+
+	/**
+	 * @param AttributeGroup[] $attrGroups
+	 * @return array
+	 */
+	protected static function findAvailableVersionsRangeFromAttribute(array $attrGroups): array
+	{
+		$versionRange = [];
+		foreach ($attrGroups as $attrGroup) {
+			foreach ($attrGroup->attrs as $attr) {
+				if ($attr->name->toString() === PhpStormStubsElementAvailable::class) {
+					if (count($attr->args) === 2) {
+						foreach ($attr->args as $arg) {
+							$versionRange[$arg->name->name] = (float)$arg->value->value;
+						}
+					} else {
+						$arg = $attr->args[0]->value;
+						if ($arg instanceof Array_) {
+							$value = $arg->items[0]->value;
+							if ($value instanceof String_) {
+								return ['from' => (float)$value->value];
+							}
+						} else {
+							$rangeName = $attr->args[0]->name;
+							return $rangeName === null || $rangeName->name === 'from' ?
+								['from' => (float)$arg->value, 'to' => PhpVersions::getLatest()] :
+								['from' => PhpVersions::getFirst(), 'to' => (float)$arg->value];
+						}
+					}
+				}
+			}
+		}
+		return $versionRange;
+	}
+
+	protected static function hasTentativeTypeAttribute(array $attrGroups): bool
+	{
+		foreach ($attrGroups as $attrGroup) {
+			foreach ($attrGroup->attrs as $attr) {
+				if ($attr->name->toString() === TentativeType::class) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public function hasMutedProblem(int $stubProblemType): bool
+	{
+		if (array_key_exists($stubProblemType, $this->mutedProblems)) {
+			if (in_array('ALL', $this->mutedProblems[$stubProblemType], true) ||
+				in_array((float)getenv('PHP_VERSION'), $this->mutedProblems[$stubProblemType], true)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * @param BasePHPElement $element
+	 * @return bool
+	 * @throws RuntimeException
+	 */
+	public static function entitySuitsCurrentPhpVersion(BasePHPElement $element): bool
+	{
+		return in_array((float)getenv('PHP_VERSION'), ParserUtils::getAvailableInVersions($element), true);
+	}
 }

Spacing +4 added lines, -5 removed lines

@@ -85,7 +85,7 @@ 
         $reflectionTypes = [];
         if ($type instanceof ReflectionNamedType) {
             $type->allowsNull() && $type->getName() !== 'mixed' ?
-                array_push($reflectionTypes, '?' . $type->getName()) : array_push($reflectionTypes, $type->getName());
+                array_push($reflectionTypes, '?'.$type->getName()) : array_push($reflectionTypes, $type->getName());
         }
         if ($type instanceof ReflectionUnionType) {
             foreach ($type->getTypes() as $namedType) {
@@ -128,10 +128,10 @@ 
         }
         if (empty($type->name)) {
             if (!empty($type->parts)) {
-                $typeName = $nullable ? '?' . implode('\\', $type->parts) : implode('\\', $type->parts);
+                $typeName = $nullable ? '?'.implode('\\', $type->parts) : implode('\\', $type->parts);
             }
         } else {
-            $typeName = $nullable ? '?' . $type->name : $type->name;
+            $typeName = $nullable ? '?'.$type->name : $type->name;
         }
         return $typeName;
     }
@@ -188,8 +188,7 @@ 
                         } else {
                             $rangeName = $attr->args[0]->name;
                             return $rangeName === null || $rangeName->name === 'from' ?
-                                ['from' => (float)$arg->value, 'to' => PhpVersions::getLatest()] :
-                                ['from' => PhpVersions::getFirst(), 'to' => (float)$arg->value];
+                                ['from' => (float)$arg->value, 'to' => PhpVersions::getLatest()] : ['from' => PhpVersions::getFirst(), 'to' => (float)$arg->value];
                         }
                     }
                 }

Braces +1 added lines, -2 removed lines

@@ -27,8 +27,7 @@
 use function count;
 use function in_array;
 
-abstract class BasePHPElement
-{
+abstract class BasePHPElement {
     use PHPDocElement;
 
     /** @var string|null */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/PHPParameter.php

Indentation +94 added lines, -94 removed lines

@@ -11,102 +11,102 @@
 
 class PHPParameter extends BasePHPElement
 {
-    public $indexInSignature = 0;
-    /** @var string[] */
-    public $typesFromSignature = [];
-    /** @var string[][] */
-    public $typesFromAttribute = [];
-    /** @var string[] */
-    public $typesFromPhpDoc = [];
-    public $is_vararg = false;
-    public $is_passed_by_ref = false;
-    public $isOptional = false;
-    public $defaultValue;
+	public $indexInSignature = 0;
+	/** @var string[] */
+	public $typesFromSignature = [];
+	/** @var string[][] */
+	public $typesFromAttribute = [];
+	/** @var string[] */
+	public $typesFromPhpDoc = [];
+	public $is_vararg = false;
+	public $is_passed_by_ref = false;
+	public $isOptional = false;
+	public $defaultValue;
 
-    /**
-     * @param ReflectionParameter $reflectionObject
-     * @return static
-     */
-    public function readObjectFromReflection($reflectionObject)
-    {
-        $this->name = $reflectionObject->name;
-        $this->typesFromSignature = self::getReflectionTypeAsArray($reflectionObject->getType());
-        $this->is_vararg = $reflectionObject->isVariadic();
-        $this->is_passed_by_ref = $reflectionObject->isPassedByReference() && !$reflectionObject->canBePassedByValue();
-        $this->isOptional = $reflectionObject->isOptional();
-        $this->indexInSignature = $reflectionObject->getPosition();
-        if ($reflectionObject->isDefaultValueAvailable()) {
-            $this->defaultValue = $reflectionObject->getDefaultValue();
-            if (in_array('bool', $this->typesFromSignature, true)) {
-                $this->defaultValue = $reflectionObject->getDefaultValue() ? 'true' : 'false';
-            }
-        }
-        return $this;
-    }
+	/**
+	 * @param ReflectionParameter $reflectionObject
+	 * @return static
+	 */
+	public function readObjectFromReflection($reflectionObject)
+	{
+		$this->name = $reflectionObject->name;
+		$this->typesFromSignature = self::getReflectionTypeAsArray($reflectionObject->getType());
+		$this->is_vararg = $reflectionObject->isVariadic();
+		$this->is_passed_by_ref = $reflectionObject->isPassedByReference() && !$reflectionObject->canBePassedByValue();
+		$this->isOptional = $reflectionObject->isOptional();
+		$this->indexInSignature = $reflectionObject->getPosition();
+		if ($reflectionObject->isDefaultValueAvailable()) {
+			$this->defaultValue = $reflectionObject->getDefaultValue();
+			if (in_array('bool', $this->typesFromSignature, true)) {
+				$this->defaultValue = $reflectionObject->getDefaultValue() ? 'true' : 'false';
+			}
+		}
+		return $this;
+	}
 
-    /**
-     * @param Param $node
-     * @return static
-     */
-    public function readObjectFromStubNode($node)
-    {
-        $this->name = $node->var->name;
+	/**
+	 * @param Param $node
+	 * @return static
+	 */
+	public function readObjectFromStubNode($node)
+	{
+		$this->name = $node->var->name;
 
-        $this->typesFromAttribute = self::findTypesFromAttribute($node->attrGroups);
-        $this->typesFromSignature = self::convertParsedTypeToArray($node->type);
-        $this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
-        $this->is_vararg = $node->variadic;
-        $this->is_passed_by_ref = $node->byRef;
-        $this->defaultValue = $node->default;
-        $this->isOptional = !empty($this->defaultValue) || $this->is_vararg;
-        return $this;
-    }
+		$this->typesFromAttribute = self::findTypesFromAttribute($node->attrGroups);
+		$this->typesFromSignature = self::convertParsedTypeToArray($node->type);
+		$this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
+		$this->is_vararg = $node->variadic;
+		$this->is_passed_by_ref = $node->byRef;
+		$this->defaultValue = $node->default;
+		$this->isOptional = !empty($this->defaultValue) || $this->is_vararg;
+		return $this;
+	}
 
-    /**
-     * @param stdClass|array $jsonData
-     * @throws Exception
-     */
-    public function readMutedProblems($jsonData): void
-    {
-        foreach ($jsonData as $parameter) {
-            if ($parameter->name === $this->name && !empty($parameter->problems)) {
-                foreach ($parameter->problems as $problem) {
-                    switch ($problem->description) {
-                        case 'parameter type mismatch':
-                            $this->mutedProblems[StubProblemType::PARAMETER_TYPE_MISMATCH] = $problem->versions;
-                            break;
-                        case 'parameter reference':
-                            $this->mutedProblems[StubProblemType::PARAMETER_REFERENCE] = $problem->versions;
-                            break;
-                        case 'parameter vararg':
-                            $this->mutedProblems[StubProblemType::PARAMETER_VARARG] = $problem->versions;
-                            break;
-                        case 'has scalar typehint':
-                            $this->mutedProblems[StubProblemType::PARAMETER_HAS_SCALAR_TYPEHINT] = $problem->versions;
-                            break;
-                        case 'parameter name mismatch':
-                            $this->mutedProblems[StubProblemType::PARAMETER_NAME_MISMATCH] = $problem->versions;
-                            break;
-                        case 'has nullable typehint':
-                            $this->mutedProblems[StubProblemType::HAS_NULLABLE_TYPEHINT] = $problem->versions;
-                            break;
-                        case 'has union typehint':
-                            $this->mutedProblems[StubProblemType::HAS_UNION_TYPEHINT] = $problem->versions;
-                            break;
-                        case 'has type mismatch in signature and phpdoc':
-                            $this->mutedProblems[StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE] = $problem->versions;
-                            break;
-                        case 'wrong default value':
-                            $this->mutedProblems[StubProblemType::WRONG_PARAMETER_DEFAULT_VALUE] = $problem->versions;
-                            break;
-                        case 'wrong optionallity':
-                            $this->mutedProblems[StubProblemType::WRONG_OPTIONALLITY] = $problem->versions;
-                            break;
-                        default:
-                            throw new Exception("Unexpected value $problem->description");
-                    }
-                }
-            }
-        }
-    }
+	/**
+	 * @param stdClass|array $jsonData
+	 * @throws Exception
+	 */
+	public function readMutedProblems($jsonData): void
+	{
+		foreach ($jsonData as $parameter) {
+			if ($parameter->name === $this->name && !empty($parameter->problems)) {
+				foreach ($parameter->problems as $problem) {
+					switch ($problem->description) {
+						case 'parameter type mismatch':
+							$this->mutedProblems[StubProblemType::PARAMETER_TYPE_MISMATCH] = $problem->versions;
+							break;
+						case 'parameter reference':
+							$this->mutedProblems[StubProblemType::PARAMETER_REFERENCE] = $problem->versions;
+							break;
+						case 'parameter vararg':
+							$this->mutedProblems[StubProblemType::PARAMETER_VARARG] = $problem->versions;
+							break;
+						case 'has scalar typehint':
+							$this->mutedProblems[StubProblemType::PARAMETER_HAS_SCALAR_TYPEHINT] = $problem->versions;
+							break;
+						case 'parameter name mismatch':
+							$this->mutedProblems[StubProblemType::PARAMETER_NAME_MISMATCH] = $problem->versions;
+							break;
+						case 'has nullable typehint':
+							$this->mutedProblems[StubProblemType::HAS_NULLABLE_TYPEHINT] = $problem->versions;
+							break;
+						case 'has union typehint':
+							$this->mutedProblems[StubProblemType::HAS_UNION_TYPEHINT] = $problem->versions;
+							break;
+						case 'has type mismatch in signature and phpdoc':
+							$this->mutedProblems[StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE] = $problem->versions;
+							break;
+						case 'wrong default value':
+							$this->mutedProblems[StubProblemType::WRONG_PARAMETER_DEFAULT_VALUE] = $problem->versions;
+							break;
+						case 'wrong optionallity':
+							$this->mutedProblems[StubProblemType::WRONG_OPTIONALLITY] = $problem->versions;
+							break;
+						default:
+							throw new Exception("Unexpected value $problem->description");
+					}
+				}
+			}
+		}
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -9,8 +9,7 @@
 use stdClass;
 use function in_array;
 
-class PHPParameter extends BasePHPElement
-{
+class PHPParameter extends BasePHPElement {
     public $indexInSignature = 0;
     /** @var string[] */
     public $typesFromSignature = [];

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/PHPClass.php

Indentation +170 added lines, -170 removed lines

@@ -16,182 +16,182 @@
 
 class PHPClass extends BasePHPClass
 {
-    /**
-     * @var false|string|null
-     */
-    public $parentClass;
-    public $interfaces = [];
-    /** @var PHPProperty[] */
-    public $properties = [];
+	/**
+	 * @var false|string|null
+	 */
+	public $parentClass;
+	public $interfaces = [];
+	/** @var PHPProperty[] */
+	public $properties = [];
 
-    /**
-     * @param ReflectionClass $reflectionObject
-     * @return static
-     */
-    public function readObjectFromReflection($reflectionObject)
-    {
-        $this->name = $reflectionObject->getName();
-        $parent = $reflectionObject->getParentClass();
-        if ($parent !== false) {
-            $this->parentClass = $parent->getName();
-        }
-        $this->interfaces = $reflectionObject->getInterfaceNames();
-        $this->isFinal = $reflectionObject->isFinal();
-        foreach ($reflectionObject->getMethods() as $method) {
-            if ($method->getDeclaringClass()->getName() !== $this->name) {
-                continue;
-            }
-            $parsedMethod = (new PHPMethod())->readObjectFromReflection($method);
-            $this->addMethod($parsedMethod);
-        }
+	/**
+	 * @param ReflectionClass $reflectionObject
+	 * @return static
+	 */
+	public function readObjectFromReflection($reflectionObject)
+	{
+		$this->name = $reflectionObject->getName();
+		$parent = $reflectionObject->getParentClass();
+		if ($parent !== false) {
+			$this->parentClass = $parent->getName();
+		}
+		$this->interfaces = $reflectionObject->getInterfaceNames();
+		$this->isFinal = $reflectionObject->isFinal();
+		foreach ($reflectionObject->getMethods() as $method) {
+			if ($method->getDeclaringClass()->getName() !== $this->name) {
+				continue;
+			}
+			$parsedMethod = (new PHPMethod())->readObjectFromReflection($method);
+			$this->addMethod($parsedMethod);
+		}
 
-        foreach ($reflectionObject->getReflectionConstants() as $constant) {
-            if ($constant->getDeclaringClass()->getName() !== $this->name) {
-                continue;
-            }
-            $parsedConstant = (new PHPConst())->readObjectFromReflection($constant);
-            $this->addConstant($parsedConstant);
-        }
+		foreach ($reflectionObject->getReflectionConstants() as $constant) {
+			if ($constant->getDeclaringClass()->getName() !== $this->name) {
+				continue;
+			}
+			$parsedConstant = (new PHPConst())->readObjectFromReflection($constant);
+			$this->addConstant($parsedConstant);
+		}
 
-        foreach ($reflectionObject->getProperties() as $property) {
-            if ($property->getDeclaringClass()->getName() !== $this->name) {
-                continue;
-            }
-            $parsedProperty = (new PHPProperty())->readObjectFromReflection($property);
-            $this->addProperty($parsedProperty);
-        }
-        return $this;
-    }
+		foreach ($reflectionObject->getProperties() as $property) {
+			if ($property->getDeclaringClass()->getName() !== $this->name) {
+				continue;
+			}
+			$parsedProperty = (new PHPProperty())->readObjectFromReflection($property);
+			$this->addProperty($parsedProperty);
+		}
+		return $this;
+	}
 
-    /**
-     * @param Class_ $node
-     * @return static
-     */
-    public function readObjectFromStubNode($node)
-    {
-        $this->name = self::getFQN($node);
-        $this->isFinal = $node->isFinal();
-        $this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
-        $this->collectTags($node);
-        if (!empty($node->extends)) {
-            $this->parentClass = '';
-            foreach ($node->extends->parts as $part) {
-                $this->parentClass .= "\\$part";
-            }
-            $this->parentClass = ltrim($this->parentClass, "\\");
-        }
-        if (!empty($node->implements)) {
-            foreach ($node->implements as $interfaceObject) {
-                $interfaceFQN = '';
-                foreach ($interfaceObject->parts as $interface) {
-                    $interfaceFQN .= "\\$interface";
-                }
-                $this->interfaces[] = ltrim($interfaceFQN, "\\");
-            }
-        }
-        foreach ($node->getProperties() as $property) {
-            $parsedProperty = (new PHPProperty($this->name))->readObjectFromStubNode($property);
-            $this->addProperty($parsedProperty);
-        }
-        if ($node->getDocComment() !== null) {
-            $docBlock = DocBlockFactory::createInstance()->create($node->getDocComment()->getText());
-            /** @var PropertyRead[] $properties */
-            $properties = array_merge(
-                $docBlock->getTagsByName('property-read'),
-                $docBlock->getTagsByName('property')
-            );
-            foreach ($properties as $property) {
-                $propertyName = $property->getVariableName();
-                assert($propertyName !== '', "@property name is empty in class $this->name");
-                $newProperty = new PHPProperty($this->name);
-                $newProperty->is_static = false;
-                $newProperty->access = 'public';
-                $newProperty->name = $propertyName;
-                $newProperty->parentName = $this->name;
-                $newProperty->typesFromSignature = self::convertParsedTypeToArray($property->getType());
-                assert(
-                    !array_key_exists($propertyName, $this->properties),
-                    "Property '$propertyName' is already declared in class '$this->name'"
-                );
-                $this->properties[$propertyName] = $newProperty;
-            }
-        }
+	/**
+	 * @param Class_ $node
+	 * @return static
+	 */
+	public function readObjectFromStubNode($node)
+	{
+		$this->name = self::getFQN($node);
+		$this->isFinal = $node->isFinal();
+		$this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
+		$this->collectTags($node);
+		if (!empty($node->extends)) {
+			$this->parentClass = '';
+			foreach ($node->extends->parts as $part) {
+				$this->parentClass .= "\\$part";
+			}
+			$this->parentClass = ltrim($this->parentClass, "\\");
+		}
+		if (!empty($node->implements)) {
+			foreach ($node->implements as $interfaceObject) {
+				$interfaceFQN = '';
+				foreach ($interfaceObject->parts as $interface) {
+					$interfaceFQN .= "\\$interface";
+				}
+				$this->interfaces[] = ltrim($interfaceFQN, "\\");
+			}
+		}
+		foreach ($node->getProperties() as $property) {
+			$parsedProperty = (new PHPProperty($this->name))->readObjectFromStubNode($property);
+			$this->addProperty($parsedProperty);
+		}
+		if ($node->getDocComment() !== null) {
+			$docBlock = DocBlockFactory::createInstance()->create($node->getDocComment()->getText());
+			/** @var PropertyRead[] $properties */
+			$properties = array_merge(
+				$docBlock->getTagsByName('property-read'),
+				$docBlock->getTagsByName('property')
+			);
+			foreach ($properties as $property) {
+				$propertyName = $property->getVariableName();
+				assert($propertyName !== '', "@property name is empty in class $this->name");
+				$newProperty = new PHPProperty($this->name);
+				$newProperty->is_static = false;
+				$newProperty->access = 'public';
+				$newProperty->name = $propertyName;
+				$newProperty->parentName = $this->name;
+				$newProperty->typesFromSignature = self::convertParsedTypeToArray($property->getType());
+				assert(
+					!array_key_exists($propertyName, $this->properties),
+					"Property '$propertyName' is already declared in class '$this->name'"
+				);
+				$this->properties[$propertyName] = $newProperty;
+			}
+		}
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * @param stdClass|array $jsonData
-     * @throws Exception
-     */
-    public function readMutedProblems($jsonData): void
-    {
-        foreach ($jsonData as $class) {
-            if ($class->name === $this->name) {
-                if (!empty($class->problems)) {
-                    foreach ($class->problems as $problem) {
-                        switch ($problem->description) {
-                            case 'wrong parent':
-                                $this->mutedProblems[StubProblemType::WRONG_PARENT] = $problem->versions;
-                                break;
-                            case 'wrong interface':
-                                $this->mutedProblems[StubProblemType::WRONG_INTERFACE] = $problem->versions;
-                                break;
-                            case 'missing class':
-                                $this->mutedProblems[StubProblemType::STUB_IS_MISSED] = $problem->versions;
-                                break;
-                            case 'has wrong final modifier':
-                                $this->mutedProblems[StubProblemType::WRONG_FINAL_MODIFIER] = $problem->versions;
-                                break;
-                            default:
-                                throw new Exception("Unexpected value $problem->description");
-                        }
-                    }
-                }
-                if (!empty($class->methods)) {
-                    foreach ($this->methods as $method) {
-                        $method->readMutedProblems($class->methods);
-                    }
-                }
-                if (!empty($class->constants)) {
-                    foreach ($this->constants as $constant) {
-                        $constant->readMutedProblems($class->constants);
-                    }
-                }
-                return;
-            }
-        }
-    }
+	/**
+	 * @param stdClass|array $jsonData
+	 * @throws Exception
+	 */
+	public function readMutedProblems($jsonData): void
+	{
+		foreach ($jsonData as $class) {
+			if ($class->name === $this->name) {
+				if (!empty($class->problems)) {
+					foreach ($class->problems as $problem) {
+						switch ($problem->description) {
+							case 'wrong parent':
+								$this->mutedProblems[StubProblemType::WRONG_PARENT] = $problem->versions;
+								break;
+							case 'wrong interface':
+								$this->mutedProblems[StubProblemType::WRONG_INTERFACE] = $problem->versions;
+								break;
+							case 'missing class':
+								$this->mutedProblems[StubProblemType::STUB_IS_MISSED] = $problem->versions;
+								break;
+							case 'has wrong final modifier':
+								$this->mutedProblems[StubProblemType::WRONG_FINAL_MODIFIER] = $problem->versions;
+								break;
+							default:
+								throw new Exception("Unexpected value $problem->description");
+						}
+					}
+				}
+				if (!empty($class->methods)) {
+					foreach ($this->methods as $method) {
+						$method->readMutedProblems($class->methods);
+					}
+				}
+				if (!empty($class->constants)) {
+					foreach ($this->constants as $constant) {
+						$constant->readMutedProblems($class->constants);
+					}
+				}
+				return;
+			}
+		}
+	}
 
-    public function addProperty(PHPProperty $parsedProperty): void
-    {
-        if (isset($parsedProperty->name)) {
-            if (array_key_exists($parsedProperty->name, $this->properties)) {
-                $amount = count(array_filter(
-                    $this->properties,
-                    function (PHPProperty $nextProperty) use ($parsedProperty) {
-                        return $nextProperty->name === $parsedProperty->name;
-                    }
-                ));
-                $this->properties[$parsedProperty->name . '_duplicated_' . $amount] = $parsedProperty;
-            } else {
-                $this->properties[$parsedProperty->name] = $parsedProperty;
-            }
-        }
-    }
+	public function addProperty(PHPProperty $parsedProperty): void
+	{
+		if (isset($parsedProperty->name)) {
+			if (array_key_exists($parsedProperty->name, $this->properties)) {
+				$amount = count(array_filter(
+					$this->properties,
+					function (PHPProperty $nextProperty) use ($parsedProperty) {
+						return $nextProperty->name === $parsedProperty->name;
+					}
+				));
+				$this->properties[$parsedProperty->name . '_duplicated_' . $amount] = $parsedProperty;
+			} else {
+				$this->properties[$parsedProperty->name] = $parsedProperty;
+			}
+		}
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public function getProperty($propertyName): ?PHPProperty
-    {
-        $properties = array_filter($this->properties, function (PHPProperty $property) use ($propertyName): bool {
-            return $property->name === $propertyName && $property->duplicateOtherElement === false
-                && BasePHPElement::entitySuitsCurrentPhpVersion($property);
-        });
-        if (empty($properties)) {
-            throw new RuntimeException("Property $propertyName not found in stubs for set language version");
-        }
-        return array_pop($properties);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public function getProperty($propertyName): ?PHPProperty
+	{
+		$properties = array_filter($this->properties, function (PHPProperty $property) use ($propertyName): bool {
+			return $property->name === $propertyName && $property->duplicateOtherElement === false
+				&& BasePHPElement::entitySuitsCurrentPhpVersion($property);
+		});
+		if (empty($properties)) {
+			throw new RuntimeException("Property $propertyName not found in stubs for set language version");
+		}
+		return array_pop($properties);
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -169,11 +169,11 @@ 
             if (array_key_exists($parsedProperty->name, $this->properties)) {
                 $amount = count(array_filter(
                     $this->properties,
-                    function (PHPProperty $nextProperty) use ($parsedProperty) {
+                    function(PHPProperty $nextProperty) use ($parsedProperty) {
                         return $nextProperty->name === $parsedProperty->name;
                     }
                 ));
-                $this->properties[$parsedProperty->name . '_duplicated_' . $amount] = $parsedProperty;
+                $this->properties[$parsedProperty->name.'_duplicated_'.$amount] = $parsedProperty;
             } else {
                 $this->properties[$parsedProperty->name] = $parsedProperty;
             }
@@ -185,7 +185,7 @@ 
      */
     public function getProperty($propertyName): ?PHPProperty
     {
-        $properties = array_filter($this->properties, function (PHPProperty $property) use ($propertyName): bool {
+        $properties = array_filter($this->properties, function(PHPProperty $property) use ($propertyName) : bool {
             return $property->name === $propertyName && $property->duplicateOtherElement === false
                 && BasePHPElement::entitySuitsCurrentPhpVersion($property);
         });

Braces +1 added lines, -2 removed lines

@@ -14,8 +14,7 @@
 use function assert;
 use function count;
 
-class PHPClass extends BasePHPClass
-{
+class PHPClass extends BasePHPClass {
     /**
      * @var false|string|null
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/BasePHPClass.php

Indentation +69 added lines, -69 removed lines

@@ -9,79 +9,79 @@
 
 abstract class BasePHPClass extends BasePHPElement
 {
-    /**
-     * @var PHPMethod[]
-     */
-    public $methods = [];
+	/**
+	 * @var PHPMethod[]
+	 */
+	public $methods = [];
 
-    /**
-     * @var PHPConst[]
-     */
-    public $constants = [];
+	/**
+	 * @var PHPConst[]
+	 */
+	public $constants = [];
 
-    public $isFinal = false;
+	public $isFinal = false;
 
-    public function addConstant(PHPConst $parsedConstant): void
-    {
-        if (isset($parsedConstant->name)) {
-            if (array_key_exists($parsedConstant->name, $this->constants)) {
-                $amount = count(array_filter(
-                    $this->constants,
-                    function (PHPConst $nextConstant) use ($parsedConstant) {
-                        return $nextConstant->name === $parsedConstant->name;
-                    }
-                ));
-                $this->constants[$parsedConstant->name . '_duplicated_' . $amount] = $parsedConstant;
-            } else {
-                $this->constants[$parsedConstant->name] = $parsedConstant;
-            }
-        }
-    }
+	public function addConstant(PHPConst $parsedConstant): void
+	{
+		if (isset($parsedConstant->name)) {
+			if (array_key_exists($parsedConstant->name, $this->constants)) {
+				$amount = count(array_filter(
+					$this->constants,
+					function (PHPConst $nextConstant) use ($parsedConstant) {
+						return $nextConstant->name === $parsedConstant->name;
+					}
+				));
+				$this->constants[$parsedConstant->name . '_duplicated_' . $amount] = $parsedConstant;
+			} else {
+				$this->constants[$parsedConstant->name] = $parsedConstant;
+			}
+		}
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public function getConstant($constantName): ?PHPConst
-    {
-        $constants = array_filter($this->constants, function (PHPConst $constant) use ($constantName): bool {
-            return $constant->name === $constantName && $constant->duplicateOtherElement === false
-                && BasePHPElement::entitySuitsCurrentPhpVersion($constant);
-        });
-        if (empty($constants)) {
-            throw new RuntimeException("Constant $constantName not found in stubs for set language version");
-        }
-        return array_pop($constants);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public function getConstant($constantName): ?PHPConst
+	{
+		$constants = array_filter($this->constants, function (PHPConst $constant) use ($constantName): bool {
+			return $constant->name === $constantName && $constant->duplicateOtherElement === false
+				&& BasePHPElement::entitySuitsCurrentPhpVersion($constant);
+		});
+		if (empty($constants)) {
+			throw new RuntimeException("Constant $constantName not found in stubs for set language version");
+		}
+		return array_pop($constants);
+	}
 
-    public function addMethod(PHPMethod $parsedMethod): void
-    {
-        if (isset($parsedMethod->name)) {
-            if (array_key_exists($parsedMethod->name, $this->methods)) {
-                $amount = count(array_filter(
-                    $this->methods,
-                    function (PHPMethod $nextMethod) use ($parsedMethod) {
-                        return $nextMethod->name === $parsedMethod->name;
-                    }
-                ));
-                $this->methods[$parsedMethod->name . '_duplicated_' . $amount] = $parsedMethod;
-            } else {
-                $this->methods[$parsedMethod->name] = $parsedMethod;
-            }
-        }
-    }
+	public function addMethod(PHPMethod $parsedMethod): void
+	{
+		if (isset($parsedMethod->name)) {
+			if (array_key_exists($parsedMethod->name, $this->methods)) {
+				$amount = count(array_filter(
+					$this->methods,
+					function (PHPMethod $nextMethod) use ($parsedMethod) {
+						return $nextMethod->name === $parsedMethod->name;
+					}
+				));
+				$this->methods[$parsedMethod->name . '_duplicated_' . $amount] = $parsedMethod;
+			} else {
+				$this->methods[$parsedMethod->name] = $parsedMethod;
+			}
+		}
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public function getMethod(string $methodName): ?PHPMethod
-    {
-        $methods = array_filter($this->methods, function (PHPMethod $method) use ($methodName): bool {
-            return $method->name === $methodName && $method->duplicateOtherElement === false
-                && BasePHPElement::entitySuitsCurrentPhpVersion($method);
-        });
-        if (empty($methods)) {
-            throw new RuntimeException("Method $methodName not found in stubs for set language version");
-        }
-        return array_pop($methods);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public function getMethod(string $methodName): ?PHPMethod
+	{
+		$methods = array_filter($this->methods, function (PHPMethod $method) use ($methodName): bool {
+			return $method->name === $methodName && $method->duplicateOtherElement === false
+				&& BasePHPElement::entitySuitsCurrentPhpVersion($method);
+		});
+		if (empty($methods)) {
+			throw new RuntimeException("Method $methodName not found in stubs for set language version");
+		}
+		return array_pop($methods);
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -27,11 +27,11 @@ 
             if (array_key_exists($parsedConstant->name, $this->constants)) {
                 $amount = count(array_filter(
                     $this->constants,
-                    function (PHPConst $nextConstant) use ($parsedConstant) {
+                    function(PHPConst $nextConstant) use ($parsedConstant) {
                         return $nextConstant->name === $parsedConstant->name;
                     }
                 ));
-                $this->constants[$parsedConstant->name . '_duplicated_' . $amount] = $parsedConstant;
+                $this->constants[$parsedConstant->name.'_duplicated_'.$amount] = $parsedConstant;
             } else {
                 $this->constants[$parsedConstant->name] = $parsedConstant;
             }
@@ -43,7 +43,7 @@ 
      */
     public function getConstant($constantName): ?PHPConst
     {
-        $constants = array_filter($this->constants, function (PHPConst $constant) use ($constantName): bool {
+        $constants = array_filter($this->constants, function(PHPConst $constant) use ($constantName) : bool {
             return $constant->name === $constantName && $constant->duplicateOtherElement === false
                 && BasePHPElement::entitySuitsCurrentPhpVersion($constant);
         });
@@ -59,11 +59,11 @@ 
             if (array_key_exists($parsedMethod->name, $this->methods)) {
                 $amount = count(array_filter(
                     $this->methods,
-                    function (PHPMethod $nextMethod) use ($parsedMethod) {
+                    function(PHPMethod $nextMethod) use ($parsedMethod) {
                         return $nextMethod->name === $parsedMethod->name;
                     }
                 ));
-                $this->methods[$parsedMethod->name . '_duplicated_' . $amount] = $parsedMethod;
+                $this->methods[$parsedMethod->name.'_duplicated_'.$amount] = $parsedMethod;
             } else {
                 $this->methods[$parsedMethod->name] = $parsedMethod;
             }
@@ -75,7 +75,7 @@ 
      */
     public function getMethod(string $methodName): ?PHPMethod
     {
-        $methods = array_filter($this->methods, function (PHPMethod $method) use ($methodName): bool {
+        $methods = array_filter($this->methods, function(PHPMethod $method) use ($methodName) : bool {
             return $method->name === $methodName && $method->duplicateOtherElement === false
                 && BasePHPElement::entitySuitsCurrentPhpVersion($method);
         });

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 use function array_key_exists;
 use function count;
 
-abstract class BasePHPClass extends BasePHPElement
-{
+abstract class BasePHPClass extends BasePHPElement {
     /**
      * @var PHPMethod[]
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/PHPDocElement.php

Indentation +69 added lines, -69 removed lines

@@ -16,84 +16,84 @@
 
 trait PHPDocElement
 {
-    /**
-     * @var Link[]
-     */
-    public $links = [];
+	/**
+	 * @var Link[]
+	 */
+	public $links = [];
 
-    /**
-     * @var string
-     */
-    public $phpdoc = '';
+	/**
+	 * @var string
+	 */
+	public $phpdoc = '';
 
-    /**
-     * @var See[]
-     */
-    public $see = [];
+	/**
+	 * @var See[]
+	 */
+	public $see = [];
 
-    /**
-     * @var Since[]
-     */
-    public $sinceTags = [];
+	/**
+	 * @var Since[]
+	 */
+	public $sinceTags = [];
 
-    /**
-     * @var Deprecated[]
-     */
-    public $deprecatedTags = [];
+	/**
+	 * @var Deprecated[]
+	 */
+	public $deprecatedTags = [];
 
-    /**
-     * @var RemovedTag[]
-     */
-    public $removedTags = [];
+	/**
+	 * @var RemovedTag[]
+	 */
+	public $removedTags = [];
 
-    /**
-     * @var Param[]
-     */
-    public $paramTags = [];
+	/**
+	 * @var Param[]
+	 */
+	public $paramTags = [];
 
-    /**
-     * @var Var_[]
-     */
-    public $varTags = [];
+	/**
+	 * @var Var_[]
+	 */
+	public $varTags = [];
 
-    /**
-     * @var string[]
-     */
-    public $tagNames = [];
+	/**
+	 * @var string[]
+	 */
+	public $tagNames = [];
 
-    /**
-     * @var bool
-     */
-    public $hasInheritDocTag = false;
+	/**
+	 * @var bool
+	 */
+	public $hasInheritDocTag = false;
 
-    /**
-     * @var bool
-     */
-    public $hasInternalMetaTag = false;
+	/**
+	 * @var bool
+	 */
+	public $hasInternalMetaTag = false;
 
-    protected function collectTags(Node $node): void {
-        if ($node->getDocComment() !== null) {
-            try {
-                $text = $node->getDocComment()->getText();
-                $this->phpdoc = $text;
-                $phpDoc = DocFactoryProvider::getDocFactory()->create($text);
-                $tags = $phpDoc->getTags();
-                foreach ($tags as $tag) {
-                    $this->tagNames[] = $tag->getName();
-                }
-                $this->paramTags = $phpDoc->getTagsByName('param');
-                $this->varTags = $phpDoc->getTagsByName('var');
-                $this->links = $phpDoc->getTagsByName('link');
-                $this->see = $phpDoc->getTagsByName('see');
-                $this->sinceTags = $phpDoc->getTagsByName('since');
-                $this->deprecatedTags = $phpDoc->getTagsByName('deprecated');
-                $this->removedTags = $phpDoc->getTagsByName('removed');
-                $this->hasInternalMetaTag = $phpDoc->hasTag('meta');
-                $this->hasInheritDocTag = $phpDoc->hasTag('inheritdoc') || $phpDoc->hasTag('inheritDoc') ||
-                    stripos($phpDoc->getSummary(), 'inheritdoc') > 0;
-            } catch (Exception $e) {
-                $this->parseError = $e;
-            }
-        }
-    }
+	protected function collectTags(Node $node): void {
+		if ($node->getDocComment() !== null) {
+			try {
+				$text = $node->getDocComment()->getText();
+				$this->phpdoc = $text;
+				$phpDoc = DocFactoryProvider::getDocFactory()->create($text);
+				$tags = $phpDoc->getTags();
+				foreach ($tags as $tag) {
+					$this->tagNames[] = $tag->getName();
+				}
+				$this->paramTags = $phpDoc->getTagsByName('param');
+				$this->varTags = $phpDoc->getTagsByName('var');
+				$this->links = $phpDoc->getTagsByName('link');
+				$this->see = $phpDoc->getTagsByName('see');
+				$this->sinceTags = $phpDoc->getTagsByName('since');
+				$this->deprecatedTags = $phpDoc->getTagsByName('deprecated');
+				$this->removedTags = $phpDoc->getTagsByName('removed');
+				$this->hasInternalMetaTag = $phpDoc->hasTag('meta');
+				$this->hasInheritDocTag = $phpDoc->hasTag('inheritdoc') || $phpDoc->hasTag('inheritDoc') ||
+					stripos($phpDoc->getSummary(), 'inheritdoc') > 0;
+			} catch (Exception $e) {
+				$this->parseError = $e;
+			}
+		}
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -14,8 +14,7 @@
 use StubTests\Model\Tags\RemovedTag;
 use StubTests\Parsers\DocFactoryProvider;
 
-trait PHPDocElement
-{
+trait PHPDocElement {
     /**
      * @var Link[]
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/PhpVersions.php

Indentation +39 added lines, -39 removed lines

@@ -11,43 +11,43 @@
 
 class PhpVersions implements ArrayAccess, IteratorAggregate
 {
-    private static $versions = [5.3, 5.4, 5.5, 5.6, 7.0, 7.1, 7.2, 7.3, 7.4, 8.0, 8.1];
-
-    public static function getLatest()
-    {
-        return end(self::$versions);
-    }
-
-    public static function getFirst(): float
-    {
-        return self::$versions[0];
-    }
-
-    public function offsetExists($offset): bool
-    {
-        return isset(self::$versions[$offset]);
-    }
-
-    #[ReturnTypeWillChange]
-    public function offsetGet($offset)
-    {
-        return $this->offsetExists($offset) ? self::$versions[$offset] : null;
-    }
-
-    #[ReturnTypeWillChange]
-    public function offsetSet($offset, $value)
-    {
-        throw new RuntimeException('Unsupported operation');
-    }
-
-    #[ReturnTypeWillChange]
-    public function offsetUnset($offset)
-    {
-        throw new RuntimeException('Unsupported operation');
-    }
-
-    public function getIterator(): ArrayIterator
-    {
-        return new ArrayIterator(self::$versions);
-    }
+	private static $versions = [5.3, 5.4, 5.5, 5.6, 7.0, 7.1, 7.2, 7.3, 7.4, 8.0, 8.1];
+
+	public static function getLatest()
+	{
+		return end(self::$versions);
+	}
+
+	public static function getFirst(): float
+	{
+		return self::$versions[0];
+	}
+
+	public function offsetExists($offset): bool
+	{
+		return isset(self::$versions[$offset]);
+	}
+
+	#[ReturnTypeWillChange]
+	public function offsetGet($offset)
+	{
+		return $this->offsetExists($offset) ? self::$versions[$offset] : null;
+	}
+
+	#[ReturnTypeWillChange]
+	public function offsetSet($offset, $value)
+	{
+		throw new RuntimeException('Unsupported operation');
+	}
+
+	#[ReturnTypeWillChange]
+	public function offsetUnset($offset)
+	{
+		throw new RuntimeException('Unsupported operation');
+	}
+
+	public function getIterator(): ArrayIterator
+	{
+		return new ArrayIterator(self::$versions);
+	}
 }

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/PHPMethod.php

Indentation +161 added lines, -161 removed lines

@@ -13,172 +13,172 @@
 
 class PHPMethod extends PHPFunction
 {
-    /**
-     * @var string
-     */
-    public $access;
-    /**
-     * @var bool
-     */
-    public $isStatic;
-    /**
-     * @var bool
-     */
-    public $isFinal;
-    /**
-     * @var string
-     */
-    public $parentName;
+	/**
+	 * @var string
+	 */
+	public $access;
+	/**
+	 * @var bool
+	 */
+	public $isStatic;
+	/**
+	 * @var bool
+	 */
+	public $isFinal;
+	/**
+	 * @var string
+	 */
+	public $parentName;
 
-    /**
-     * @var bool
-     */
-    public $isReturnTypeTentative;
+	/**
+	 * @var bool
+	 */
+	public $isReturnTypeTentative;
 
-    /**
-     * @param ReflectionMethod $reflectionObject
-     * @return static
-     */
-    public function readObjectFromReflection($reflectionObject)
-    {
-        parent::readObjectFromReflection($reflectionObject);
-        $this->isStatic = $reflectionObject->isStatic();
-        $this->isFinal = $reflectionObject->isFinal();
-        $this->parentName = $reflectionObject->class;
-        if ($reflectionObject->isProtected()) {
-            $access = 'protected';
-        } elseif ($reflectionObject->isPrivate()) {
-            $access = 'private';
-        } else {
-            $access = 'public';
-        }
-        $this->access = $access;
-        if (method_exists($reflectionObject, 'hasTentativeReturnType')) {
-            $this->isReturnTypeTentative = $reflectionObject->hasTentativeReturnType();
-            if ($this->isReturnTypeTentative) {
-                $returnTypes = self::getReflectionTypeAsArray($reflectionObject->getTentativeReturnType());
-                if (!empty($returnTypes)) {
-                    array_push($this->returnTypesFromSignature, ...$returnTypes);
-                }
-            }
-        } else {
-            $this->isReturnTypeTentative = false;
-        }
-        return $this;
-    }
+	/**
+	 * @param ReflectionMethod $reflectionObject
+	 * @return static
+	 */
+	public function readObjectFromReflection($reflectionObject)
+	{
+		parent::readObjectFromReflection($reflectionObject);
+		$this->isStatic = $reflectionObject->isStatic();
+		$this->isFinal = $reflectionObject->isFinal();
+		$this->parentName = $reflectionObject->class;
+		if ($reflectionObject->isProtected()) {
+			$access = 'protected';
+		} elseif ($reflectionObject->isPrivate()) {
+			$access = 'private';
+		} else {
+			$access = 'public';
+		}
+		$this->access = $access;
+		if (method_exists($reflectionObject, 'hasTentativeReturnType')) {
+			$this->isReturnTypeTentative = $reflectionObject->hasTentativeReturnType();
+			if ($this->isReturnTypeTentative) {
+				$returnTypes = self::getReflectionTypeAsArray($reflectionObject->getTentativeReturnType());
+				if (!empty($returnTypes)) {
+					array_push($this->returnTypesFromSignature, ...$returnTypes);
+				}
+			}
+		} else {
+			$this->isReturnTypeTentative = false;
+		}
+		return $this;
+	}
 
-    /**
-     * @param ClassMethod $node
-     * @return static
-     * @throws RuntimeException
-     */
-    public function readObjectFromStubNode($node)
-    {
-        $this->parentName = self::getFQN($node->getAttribute('parent'));
-        $this->name = $node->name->name;
-        $typesFromAttribute = self::findTypesFromAttribute($node->attrGroups);
-        $this->isReturnTypeTentative = self::hasTentativeTypeAttribute($node->attrGroups);
-        $this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
-        $this->returnTypesFromAttribute = $typesFromAttribute;
-        array_push($this->returnTypesFromSignature, ...self::convertParsedTypeToArray($node->getReturnType()));
-        $this->collectTags($node);
-        $this->checkDeprecationTag($node);
-        $this->checkReturnTag($node);
+	/**
+	 * @param ClassMethod $node
+	 * @return static
+	 * @throws RuntimeException
+	 */
+	public function readObjectFromStubNode($node)
+	{
+		$this->parentName = self::getFQN($node->getAttribute('parent'));
+		$this->name = $node->name->name;
+		$typesFromAttribute = self::findTypesFromAttribute($node->attrGroups);
+		$this->isReturnTypeTentative = self::hasTentativeTypeAttribute($node->attrGroups);
+		$this->availableVersionsRangeFromAttribute = self::findAvailableVersionsRangeFromAttribute($node->attrGroups);
+		$this->returnTypesFromAttribute = $typesFromAttribute;
+		array_push($this->returnTypesFromSignature, ...self::convertParsedTypeToArray($node->getReturnType()));
+		$this->collectTags($node);
+		$this->checkDeprecationTag($node);
+		$this->checkReturnTag($node);
 
-        if (strncmp($this->name, 'PS_UNRESERVE_PREFIX_', 20) === 0) {
-            $this->name = substr($this->name, strlen('PS_UNRESERVE_PREFIX_'));
-        }
-        $index = 0;
-        foreach ($node->getParams() as $parameter) {
-            $parsedParameter = (new PHPParameter())->readObjectFromStubNode($parameter);
-            if (self::entitySuitsCurrentPhpVersion($parsedParameter)) {
-                $parsedParameter->indexInSignature = $index;
-                $this->parameters[] = $parsedParameter;
-                $index++;
-            }
-        }
+		if (strncmp($this->name, 'PS_UNRESERVE_PREFIX_', 20) === 0) {
+			$this->name = substr($this->name, strlen('PS_UNRESERVE_PREFIX_'));
+		}
+		$index = 0;
+		foreach ($node->getParams() as $parameter) {
+			$parsedParameter = (new PHPParameter())->readObjectFromStubNode($parameter);
+			if (self::entitySuitsCurrentPhpVersion($parsedParameter)) {
+				$parsedParameter->indexInSignature = $index;
+				$this->parameters[] = $parsedParameter;
+				$index++;
+			}
+		}
 
-        foreach ($this->parameters as $parameter) {
-            $relatedParamTags = array_filter($this->paramTags, function (Param $tag) use ($parameter) {
-                return $tag->getVariableName() === $parameter->name;
-            });
-            /** @var Param $relatedParamTag */
-            $relatedParamTag = array_pop($relatedParamTags);
-            if ($relatedParamTag !== null) {
-                $parameter->isOptional = $parameter->isOptional || str_contains((string)$relatedParamTag->getDescription(), '[optional]');
-            }
-        }
+		foreach ($this->parameters as $parameter) {
+			$relatedParamTags = array_filter($this->paramTags, function (Param $tag) use ($parameter) {
+				return $tag->getVariableName() === $parameter->name;
+			});
+			/** @var Param $relatedParamTag */
+			$relatedParamTag = array_pop($relatedParamTags);
+			if ($relatedParamTag !== null) {
+				$parameter->isOptional = $parameter->isOptional || str_contains((string)$relatedParamTag->getDescription(), '[optional]');
+			}
+		}
 
-        $this->isFinal = $node->isFinal();
-        $this->isStatic = $node->isStatic();
-        if ($node->isPrivate()) {
-            $this->access = 'private';
-        } elseif ($node->isProtected()) {
-            $this->access = 'protected';
-        } else {
-            $this->access = 'public';
-        }
-        return $this;
-    }
+		$this->isFinal = $node->isFinal();
+		$this->isStatic = $node->isStatic();
+		if ($node->isPrivate()) {
+			$this->access = 'private';
+		} elseif ($node->isProtected()) {
+			$this->access = 'protected';
+		} else {
+			$this->access = 'public';
+		}
+		return $this;
+	}
 
-    /**
-     * @param stdClass|array $jsonData
-     * @throws Exception
-     */
-    public function readMutedProblems($jsonData): void
-    {
-        foreach ($jsonData as $method) {
-            if ($method->name === $this->name) {
-                if (!empty($method->problems)) {
-                    foreach ($method->problems as $problem) {
-                        switch ($problem->description) {
-                            case 'parameter mismatch':
-                                $this->mutedProblems[StubProblemType::FUNCTION_PARAMETER_MISMATCH] = $problem->versions;
-                                break;
-                            case 'missing method':
-                                $this->mutedProblems[StubProblemType::STUB_IS_MISSED] = $problem->versions;
-                                break;
-                            case 'deprecated method':
-                                $this->mutedProblems[StubProblemType::FUNCTION_IS_DEPRECATED] = $problem->versions;
-                                break;
-                            case 'absent in meta':
-                                $this->mutedProblems[StubProblemType::ABSENT_IN_META] = $problem->versions;
-                                break;
-                            case 'wrong access':
-                                $this->mutedProblems[StubProblemType::FUNCTION_ACCESS] = $problem->versions;
-                                break;
-                            case 'has duplicate in stubs':
-                                $this->mutedProblems[StubProblemType::HAS_DUPLICATION] = $problem->versions;
-                                break;
-                            case 'has nullable typehint':
-                                $this->mutedProblems[StubProblemType::HAS_NULLABLE_TYPEHINT] = $problem->versions;
-                                break;
-                            case 'has union typehint':
-                                $this->mutedProblems[StubProblemType::HAS_UNION_TYPEHINT] = $problem->versions;
-                                break;
-                            case 'wrong return typehint':
-                                $this->mutedProblems[StubProblemType::WRONG_RETURN_TYPEHINT] = $problem->versions;
-                                break;
-                            case 'has type mismatch in signature and phpdoc':
-                                $this->mutedProblems[StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE] = $problem->versions;
-                                break;
-                            case 'has wrong final modifier':
-                                $this->mutedProblems[StubProblemType::WRONG_FINAL_MODIFIER] = $problem->versions;
-                                break;
-                            case 'has wrong static modifier':
-                                $this->mutedProblems[StubProblemType::WRONG_STATIC_MODIFIER] = $problem->versions;
-                                break;
-                            default:
-                                throw new Exception("Unexpected value $problem->description");
-                        }
-                    }
-                }
-                if (!empty($method->parameters)) {
-                    foreach ($this->parameters as $parameter) {
-                        $parameter->readMutedProblems($method->parameters);
-                    }
-                }
-            }
-        }
-    }
+	/**
+	 * @param stdClass|array $jsonData
+	 * @throws Exception
+	 */
+	public function readMutedProblems($jsonData): void
+	{
+		foreach ($jsonData as $method) {
+			if ($method->name === $this->name) {
+				if (!empty($method->problems)) {
+					foreach ($method->problems as $problem) {
+						switch ($problem->description) {
+							case 'parameter mismatch':
+								$this->mutedProblems[StubProblemType::FUNCTION_PARAMETER_MISMATCH] = $problem->versions;
+								break;
+							case 'missing method':
+								$this->mutedProblems[StubProblemType::STUB_IS_MISSED] = $problem->versions;
+								break;
+							case 'deprecated method':
+								$this->mutedProblems[StubProblemType::FUNCTION_IS_DEPRECATED] = $problem->versions;
+								break;
+							case 'absent in meta':
+								$this->mutedProblems[StubProblemType::ABSENT_IN_META] = $problem->versions;
+								break;
+							case 'wrong access':
+								$this->mutedProblems[StubProblemType::FUNCTION_ACCESS] = $problem->versions;
+								break;
+							case 'has duplicate in stubs':
+								$this->mutedProblems[StubProblemType::HAS_DUPLICATION] = $problem->versions;
+								break;
+							case 'has nullable typehint':
+								$this->mutedProblems[StubProblemType::HAS_NULLABLE_TYPEHINT] = $problem->versions;
+								break;
+							case 'has union typehint':
+								$this->mutedProblems[StubProblemType::HAS_UNION_TYPEHINT] = $problem->versions;
+								break;
+							case 'wrong return typehint':
+								$this->mutedProblems[StubProblemType::WRONG_RETURN_TYPEHINT] = $problem->versions;
+								break;
+							case 'has type mismatch in signature and phpdoc':
+								$this->mutedProblems[StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE] = $problem->versions;
+								break;
+							case 'has wrong final modifier':
+								$this->mutedProblems[StubProblemType::WRONG_FINAL_MODIFIER] = $problem->versions;
+								break;
+							case 'has wrong static modifier':
+								$this->mutedProblems[StubProblemType::WRONG_STATIC_MODIFIER] = $problem->versions;
+								break;
+							default:
+								throw new Exception("Unexpected value $problem->description");
+						}
+					}
+				}
+				if (!empty($method->parameters)) {
+					foreach ($this->parameters as $parameter) {
+						$parameter->readMutedProblems($method->parameters);
+					}
+				}
+			}
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -99,7 +99,7 @@
         }
 
         foreach ($this->parameters as $parameter) {
-            $relatedParamTags = array_filter($this->paramTags, function (Param $tag) use ($parameter) {
+            $relatedParamTags = array_filter($this->paramTags, function(Param $tag) use ($parameter) {
                 return $tag->getVariableName() === $parameter->name;
             });
             /** @var Param $relatedParamTag */

Braces +1 added lines, -2 removed lines

@@ -11,8 +11,7 @@
 use stdClass;
 use function strlen;
 
-class PHPMethod extends PHPFunction
-{
+class PHPMethod extends PHPFunction {
     /**
      * @var string
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Model/StubsContainer.php

Indentation +244 added lines, -244 removed lines

@@ -9,266 +9,266 @@
 
 class StubsContainer
 {
-    /**
-     * @var PHPConst[]
-     */
-    private $constants = [];
-    /**
-     * @var PHPFunction[]
-     */
-    private $functions = [];
-    /**
-     * @var PHPClass[]
-     */
-    private $classes = [];
-    /**
-     * @var PHPInterface[]
-     */
-    private $interfaces = [];
+	/**
+	 * @var PHPConst[]
+	 */
+	private $constants = [];
+	/**
+	 * @var PHPFunction[]
+	 */
+	private $functions = [];
+	/**
+	 * @var PHPClass[]
+	 */
+	private $classes = [];
+	/**
+	 * @var PHPInterface[]
+	 */
+	private $interfaces = [];
 
-    /**
-     * @return PHPConst[]
-     */
-    public function getConstants(): array
-    {
-        return $this->constants;
-    }
+	/**
+	 * @return PHPConst[]
+	 */
+	public function getConstants(): array
+	{
+		return $this->constants;
+	}
 
-    public function getConstant(string $constantName, ?string $sourceFilePath = null): ?PHPConst
-    {
-        $constants = array_filter($this->constants, function (PHPConst $const) use ($constantName): bool {
-            return $const->name === $constantName && $const->duplicateOtherElement === false
-                && BasePHPElement::entitySuitsCurrentPhpVersion($const);
-        });
-        if (count($constants) === 1) {
-            return array_pop($constants);
-        }
+	public function getConstant(string $constantName, ?string $sourceFilePath = null): ?PHPConst
+	{
+		$constants = array_filter($this->constants, function (PHPConst $const) use ($constantName): bool {
+			return $const->name === $constantName && $const->duplicateOtherElement === false
+				&& BasePHPElement::entitySuitsCurrentPhpVersion($const);
+		});
+		if (count($constants) === 1) {
+			return array_pop($constants);
+		}
 
-        if ($sourceFilePath !== null) {
-            $constants = array_filter($constants, function (PHPConst $constant) use ($sourceFilePath) {
-                return $constant->sourceFilePath === $sourceFilePath
-                    && BasePHPElement::entitySuitsCurrentPhpVersion($constant);
-            });
-        }
-        if (count($constants) > 1) {
-            throw new RuntimeException("Multiple constants with name $constantName found");
-        }
-        if (!empty($constants)) {
-            return array_pop($constants);
-        }
-        return null;
-    }
+		if ($sourceFilePath !== null) {
+			$constants = array_filter($constants, function (PHPConst $constant) use ($sourceFilePath) {
+				return $constant->sourceFilePath === $sourceFilePath
+					&& BasePHPElement::entitySuitsCurrentPhpVersion($constant);
+			});
+		}
+		if (count($constants) > 1) {
+			throw new RuntimeException("Multiple constants with name $constantName found");
+		}
+		if (!empty($constants)) {
+			return array_pop($constants);
+		}
+		return null;
+	}
 
-    public function addConstant(PHPConst $constant): void
-    {
-        if (isset($constant->name)) {
-            if (array_key_exists($constant->name, $this->constants)) {
-                $amount = count(array_filter(
-                    $this->constants,
-                    function (PHPConst $nextConstant) use ($constant) {
-                        return $nextConstant->name === $constant->name;
-                    }
-                ));
-                $this->constants[$constant->name . '_duplicated_' . $amount] = $constant;
-            } else {
-                $this->constants[$constant->name] = $constant;
-            }
-        }
-    }
+	public function addConstant(PHPConst $constant): void
+	{
+		if (isset($constant->name)) {
+			if (array_key_exists($constant->name, $this->constants)) {
+				$amount = count(array_filter(
+					$this->constants,
+					function (PHPConst $nextConstant) use ($constant) {
+						return $nextConstant->name === $constant->name;
+					}
+				));
+				$this->constants[$constant->name . '_duplicated_' . $amount] = $constant;
+			} else {
+				$this->constants[$constant->name] = $constant;
+			}
+		}
+	}
 
-    /**
-     * @return PHPFunction[]
-     */
-    public function getFunctions(): array
-    {
-        return $this->functions;
-    }
+	/**
+	 * @return PHPFunction[]
+	 */
+	public function getFunctions(): array
+	{
+		return $this->functions;
+	}
 
-    /**
-     * @param string $name
-     * @param string|null $sourceFilePath
-     * @param bool $shouldSuitCurrentPhpVersion
-     * @return PHPFunction|null
-     * @throws RuntimeException
-     */
-    public function getFunction(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPFunction
-    {
-        $functions = array_filter($this->functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $name): bool {
-            return $function->name === $name && (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
-        });
-        if (count($functions) > 1) {
-            $functions = array_filter($functions, function (PHPFunction $function): bool {
-                return $function->duplicateOtherElement === false;
-            });
-        }
-        if (count($functions) === 1) {
-            return array_pop($functions);
-        }
+	/**
+	 * @param string $name
+	 * @param string|null $sourceFilePath
+	 * @param bool $shouldSuitCurrentPhpVersion
+	 * @return PHPFunction|null
+	 * @throws RuntimeException
+	 */
+	public function getFunction(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPFunction
+	{
+		$functions = array_filter($this->functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $name): bool {
+			return $function->name === $name && (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
+		});
+		if (count($functions) > 1) {
+			$functions = array_filter($functions, function (PHPFunction $function): bool {
+				return $function->duplicateOtherElement === false;
+			});
+		}
+		if (count($functions) === 1) {
+			return array_pop($functions);
+		}
 
-        if ($sourceFilePath !== null) {
-            $functions = array_filter($functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
-                return $function->sourceFilePath === $sourceFilePath
-                    && (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
-            });
-        }
-        if (count($functions) > 1) {
-            throw new RuntimeException("Multiple functions with name $name found");
-        }
-        if (!empty($functions)) {
-            return array_pop($functions);
-        }
-        return null;
-    }
+		if ($sourceFilePath !== null) {
+			$functions = array_filter($functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+				return $function->sourceFilePath === $sourceFilePath
+					&& (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
+			});
+		}
+		if (count($functions) > 1) {
+			throw new RuntimeException("Multiple functions with name $name found");
+		}
+		if (!empty($functions)) {
+			return array_pop($functions);
+		}
+		return null;
+	}
 
-    public function addFunction(PHPFunction $function): void
-    {
-        if (isset($function->name)) {
-            if (array_key_exists($function->name, $this->functions)) {
-                $amount = count(array_filter(
-                    $this->functions,
-                    function (PHPFunction $nextFunction) use ($function) {
-                        return $nextFunction->name === $function->name;
-                    }
-                ));
-                $function->duplicateOtherElement = true;
-                $this->functions[$function->name . '_duplicated_' . $amount] = $function;
-            } else {
-                $this->functions[$function->name] = $function;
-            }
-        }
-    }
+	public function addFunction(PHPFunction $function): void
+	{
+		if (isset($function->name)) {
+			if (array_key_exists($function->name, $this->functions)) {
+				$amount = count(array_filter(
+					$this->functions,
+					function (PHPFunction $nextFunction) use ($function) {
+						return $nextFunction->name === $function->name;
+					}
+				));
+				$function->duplicateOtherElement = true;
+				$this->functions[$function->name . '_duplicated_' . $amount] = $function;
+			} else {
+				$this->functions[$function->name] = $function;
+			}
+		}
+	}
 
-    /**
-     * @return PHPClass[]
-     */
-    public function getClasses(): array
-    {
-        return $this->classes;
-    }
+	/**
+	 * @return PHPClass[]
+	 */
+	public function getClasses(): array
+	{
+		return $this->classes;
+	}
 
-    /**
-     * @param string $name
-     * @param string|null $sourceFilePath
-     * @param bool $shouldSuitCurrentPhpVersion
-     * @return PHPClass|null
-     * @throws RuntimeException
-     */
-    public function getClass(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPClass
-    {
-        $classes = array_filter($this->classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $name): bool {
-            return $class->name === $name &&
-                (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
-        });
-        if (count($classes) === 1) {
-            return array_pop($classes);
-        }
+	/**
+	 * @param string $name
+	 * @param string|null $sourceFilePath
+	 * @param bool $shouldSuitCurrentPhpVersion
+	 * @return PHPClass|null
+	 * @throws RuntimeException
+	 */
+	public function getClass(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPClass
+	{
+		$classes = array_filter($this->classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $name): bool {
+			return $class->name === $name &&
+				(!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
+		});
+		if (count($classes) === 1) {
+			return array_pop($classes);
+		}
 
-        if ($sourceFilePath !== null) {
-            $classes = array_filter($classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
-                return $class->sourceFilePath === $sourceFilePath &&
-                    (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
-            });
-        }
-        if (count($classes) > 1) {
-            throw new RuntimeException("Multiple classes with name $name found");
-        }
-        if (!empty($classes)) {
-            return array_pop($classes);
-        }
-        return null;
-    }
+		if ($sourceFilePath !== null) {
+			$classes = array_filter($classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+				return $class->sourceFilePath === $sourceFilePath &&
+					(!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
+			});
+		}
+		if (count($classes) > 1) {
+			throw new RuntimeException("Multiple classes with name $name found");
+		}
+		if (!empty($classes)) {
+			return array_pop($classes);
+		}
+		return null;
+	}
 
-    /**
-     * @return PHPClass[]
-     */
-    public function getCoreClasses(): array
-    {
-        return array_filter($this->classes, function (PHPClass $class): bool {
-            return $class->stubBelongsToCore === true;
-        });
-    }
+	/**
+	 * @return PHPClass[]
+	 */
+	public function getCoreClasses(): array
+	{
+		return array_filter($this->classes, function (PHPClass $class): bool {
+			return $class->stubBelongsToCore === true;
+		});
+	}
 
-    public function addClass(PHPClass $class): void
-    {
-        if (isset($class->name)) {
-            if (array_key_exists($class->name, $this->classes)) {
-                $amount = count(array_filter(
-                    $this->classes,
-                    function (PHPClass $nextClass) use ($class) {
-                        return $nextClass->name === $class->name;
-                    }
-                ));
-                $this->classes[$class->name . '_duplicated_' . $amount] = $class;
-            } else {
-                $this->classes[$class->name] = $class;
-            }
-        }
-    }
+	public function addClass(PHPClass $class): void
+	{
+		if (isset($class->name)) {
+			if (array_key_exists($class->name, $this->classes)) {
+				$amount = count(array_filter(
+					$this->classes,
+					function (PHPClass $nextClass) use ($class) {
+						return $nextClass->name === $class->name;
+					}
+				));
+				$this->classes[$class->name . '_duplicated_' . $amount] = $class;
+			} else {
+				$this->classes[$class->name] = $class;
+			}
+		}
+	}
 
-    /**
-     * @param string $name
-     * @param string|null $sourceFilePath
-     * @param bool $shouldSuitCurrentPhpVersion
-     * @return PHPInterface|null
-     * @throws RuntimeException
-     */
-    public function getInterface(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPInterface
-    {
-        $interfaces = array_filter($this->interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $name): bool {
-            return $interface->name === $name &&
-                (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
-        });
-        if (count($interfaces) === 1) {
-            return array_pop($interfaces);
-        }
+	/**
+	 * @param string $name
+	 * @param string|null $sourceFilePath
+	 * @param bool $shouldSuitCurrentPhpVersion
+	 * @return PHPInterface|null
+	 * @throws RuntimeException
+	 */
+	public function getInterface(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPInterface
+	{
+		$interfaces = array_filter($this->interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $name): bool {
+			return $interface->name === $name &&
+				(!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
+		});
+		if (count($interfaces) === 1) {
+			return array_pop($interfaces);
+		}
 
-        if ($sourceFilePath !== null) {
-            $interfaces = array_filter($interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
-                return $interface->sourceFilePath === $sourceFilePath &&
-                    (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
-            });
-        }
-        if (count($interfaces) > 1) {
-            throw new RuntimeException("Multiple interfaces with name $name found");
-        }
-        if (!empty($interfaces)) {
-            return array_pop($interfaces);
-        }
-        return null;
-    }
+		if ($sourceFilePath !== null) {
+			$interfaces = array_filter($interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+				return $interface->sourceFilePath === $sourceFilePath &&
+					(!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
+			});
+		}
+		if (count($interfaces) > 1) {
+			throw new RuntimeException("Multiple interfaces with name $name found");
+		}
+		if (!empty($interfaces)) {
+			return array_pop($interfaces);
+		}
+		return null;
+	}
 
-    /**
-     * @return PHPInterface[]
-     */
-    public function getInterfaces(): array
-    {
-        return $this->interfaces;
-    }
+	/**
+	 * @return PHPInterface[]
+	 */
+	public function getInterfaces(): array
+	{
+		return $this->interfaces;
+	}
 
-    /**
-     * @return PHPInterface[]
-     */
-    public function getCoreInterfaces(): array
-    {
-        return array_filter($this->interfaces, function (PHPInterface $interface): bool {
-            return $interface->stubBelongsToCore === true;
-        });
-    }
+	/**
+	 * @return PHPInterface[]
+	 */
+	public function getCoreInterfaces(): array
+	{
+		return array_filter($this->interfaces, function (PHPInterface $interface): bool {
+			return $interface->stubBelongsToCore === true;
+		});
+	}
 
-    public function addInterface(PHPInterface $interface): void
-    {
-        if (isset($interface->name)) {
-            if (array_key_exists($interface->name, $this->interfaces)) {
-                $amount = count(array_filter(
-                    $this->interfaces,
-                    function (PHPInterface $nextInterface) use ($interface) {
-                        return $nextInterface->name === $interface->name;
-                    }
-                ));
-                $this->interfaces[$interface->name . '_duplicated_' . $amount] = $interface;
-            } else {
-                $this->interfaces[$interface->name] = $interface;
-            }
-        }
-    }
+	public function addInterface(PHPInterface $interface): void
+	{
+		if (isset($interface->name)) {
+			if (array_key_exists($interface->name, $this->interfaces)) {
+				$amount = count(array_filter(
+					$this->interfaces,
+					function (PHPInterface $nextInterface) use ($interface) {
+						return $nextInterface->name === $interface->name;
+					}
+				));
+				$this->interfaces[$interface->name . '_duplicated_' . $amount] = $interface;
+			} else {
+				$this->interfaces[$interface->name] = $interface;
+			}
+		}
+	}
 }

Spacing +19 added lines, -19 removed lines

@@ -36,7 +36,7 @@ 
 
     public function getConstant(string $constantName, ?string $sourceFilePath = null): ?PHPConst
     {
-        $constants = array_filter($this->constants, function (PHPConst $const) use ($constantName): bool {
+        $constants = array_filter($this->constants, function(PHPConst $const) use ($constantName) : bool {
             return $const->name === $constantName && $const->duplicateOtherElement === false
                 && BasePHPElement::entitySuitsCurrentPhpVersion($const);
         });
@@ -45,7 +45,7 @@ 
         }
 
         if ($sourceFilePath !== null) {
-            $constants = array_filter($constants, function (PHPConst $constant) use ($sourceFilePath) {
+            $constants = array_filter($constants, function(PHPConst $constant) use ($sourceFilePath) {
                 return $constant->sourceFilePath === $sourceFilePath
                     && BasePHPElement::entitySuitsCurrentPhpVersion($constant);
             });
@@ -65,11 +65,11 @@ 
             if (array_key_exists($constant->name, $this->constants)) {
                 $amount = count(array_filter(
                     $this->constants,
-                    function (PHPConst $nextConstant) use ($constant) {
+                    function(PHPConst $nextConstant) use ($constant) {
                         return $nextConstant->name === $constant->name;
                     }
                 ));
-                $this->constants[$constant->name . '_duplicated_' . $amount] = $constant;
+                $this->constants[$constant->name.'_duplicated_'.$amount] = $constant;
             } else {
                 $this->constants[$constant->name] = $constant;
             }
@@ -93,11 +93,11 @@ 
      */
     public function getFunction(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPFunction
     {
-        $functions = array_filter($this->functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $name): bool {
+        $functions = array_filter($this->functions, function(PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $name) : bool {
             return $function->name === $name && (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
         });
         if (count($functions) > 1) {
-            $functions = array_filter($functions, function (PHPFunction $function): bool {
+            $functions = array_filter($functions, function(PHPFunction $function): bool {
                 return $function->duplicateOtherElement === false;
             });
         }
@@ -106,7 +106,7 @@ 
         }
 
         if ($sourceFilePath !== null) {
-            $functions = array_filter($functions, function (PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+            $functions = array_filter($functions, function(PHPFunction $function) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
                 return $function->sourceFilePath === $sourceFilePath
                     && (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function));
             });
@@ -126,12 +126,12 @@ 
             if (array_key_exists($function->name, $this->functions)) {
                 $amount = count(array_filter(
                     $this->functions,
-                    function (PHPFunction $nextFunction) use ($function) {
+                    function(PHPFunction $nextFunction) use ($function) {
                         return $nextFunction->name === $function->name;
                     }
                 ));
                 $function->duplicateOtherElement = true;
-                $this->functions[$function->name . '_duplicated_' . $amount] = $function;
+                $this->functions[$function->name.'_duplicated_'.$amount] = $function;
             } else {
                 $this->functions[$function->name] = $function;
             }
@@ -155,7 +155,7 @@ 
      */
     public function getClass(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPClass
     {
-        $classes = array_filter($this->classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $name): bool {
+        $classes = array_filter($this->classes, function(PHPClass $class) use ($shouldSuitCurrentPhpVersion, $name) : bool {
             return $class->name === $name &&
                 (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
         });
@@ -164,7 +164,7 @@ 
         }
 
         if ($sourceFilePath !== null) {
-            $classes = array_filter($classes, function (PHPClass $class) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+            $classes = array_filter($classes, function(PHPClass $class) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
                 return $class->sourceFilePath === $sourceFilePath &&
                     (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($class));
             });
@@ -183,7 +183,7 @@ 
      */
     public function getCoreClasses(): array
     {
-        return array_filter($this->classes, function (PHPClass $class): bool {
+        return array_filter($this->classes, function(PHPClass $class): bool {
             return $class->stubBelongsToCore === true;
         });
     }
@@ -194,11 +194,11 @@ 
             if (array_key_exists($class->name, $this->classes)) {
                 $amount = count(array_filter(
                     $this->classes,
-                    function (PHPClass $nextClass) use ($class) {
+                    function(PHPClass $nextClass) use ($class) {
                         return $nextClass->name === $class->name;
                     }
                 ));
-                $this->classes[$class->name . '_duplicated_' . $amount] = $class;
+                $this->classes[$class->name.'_duplicated_'.$amount] = $class;
             } else {
                 $this->classes[$class->name] = $class;
             }
@@ -214,7 +214,7 @@ 
      */
     public function getInterface(string $name, ?string $sourceFilePath = null, bool $shouldSuitCurrentPhpVersion = true): ?PHPInterface
     {
-        $interfaces = array_filter($this->interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $name): bool {
+        $interfaces = array_filter($this->interfaces, function(PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $name) : bool {
             return $interface->name === $name &&
                 (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
         });
@@ -223,7 +223,7 @@ 
         }
 
         if ($sourceFilePath !== null) {
-            $interfaces = array_filter($interfaces, function (PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
+            $interfaces = array_filter($interfaces, function(PHPInterface $interface) use ($shouldSuitCurrentPhpVersion, $sourceFilePath) {
                 return $interface->sourceFilePath === $sourceFilePath &&
                     (!$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($interface));
             });
@@ -250,7 +250,7 @@ 
      */
     public function getCoreInterfaces(): array
     {
-        return array_filter($this->interfaces, function (PHPInterface $interface): bool {
+        return array_filter($this->interfaces, function(PHPInterface $interface): bool {
             return $interface->stubBelongsToCore === true;
         });
     }
@@ -261,11 +261,11 @@ 
             if (array_key_exists($interface->name, $this->interfaces)) {
                 $amount = count(array_filter(
                     $this->interfaces,
-                    function (PHPInterface $nextInterface) use ($interface) {
+                    function(PHPInterface $nextInterface) use ($interface) {
                         return $nextInterface->name === $interface->name;
                     }
                 ));
-                $this->interfaces[$interface->name . '_duplicated_' . $amount] = $interface;
+                $this->interfaces[$interface->name.'_duplicated_'.$amount] = $interface;
             } else {
                 $this->interfaces[$interface->name] = $interface;
             }

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 use function array_key_exists;
 use function count;
 
-class StubsContainer
-{
+class StubsContainer {
     /**
      * @var PHPConst[]
      */