nextcloud / fulltextsearch_elasticsearch

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/EntitiesFilter.php

Indentation +78 added lines, -78 removed lines

@@ -14,86 +14,86 @@
 
 class EntitiesFilter
 {
-    /**
-     * @param BasePHPElement[] $entities
-     * @return BasePHPElement[]
-     */
-    public static function getFiltered(array $entities, callable $additionalFilter = null, int ...$problemTypes): array
-    {
-        $resultArray = [];
-        $hasProblem = false;
-        foreach ($entities as $key => $entity) {
-            foreach ($problemTypes as $problemType) {
-                if ($entity->hasMutedProblem($problemType)) {
-                    $hasProblem = true;
-                }
-            }
-            if ($entity->hasMutedProblem(StubProblemType::STUB_IS_MISSED) ||
-                $additionalFilter !== null && $additionalFilter($entity) === true) {
-                $hasProblem = true;
-            }
-            if ($hasProblem) {
-                $hasProblem = false;
-            } else {
-                $resultArray[$key] = $entity;
-            }
-        }
+	/**
+	 * @param BasePHPElement[] $entities
+	 * @return BasePHPElement[]
+	 */
+	public static function getFiltered(array $entities, callable $additionalFilter = null, int ...$problemTypes): array
+	{
+		$resultArray = [];
+		$hasProblem = false;
+		foreach ($entities as $key => $entity) {
+			foreach ($problemTypes as $problemType) {
+				if ($entity->hasMutedProblem($problemType)) {
+					$hasProblem = true;
+				}
+			}
+			if ($entity->hasMutedProblem(StubProblemType::STUB_IS_MISSED) ||
+				$additionalFilter !== null && $additionalFilter($entity) === true) {
+				$hasProblem = true;
+			}
+			if ($hasProblem) {
+				$hasProblem = false;
+			} else {
+				$resultArray[$key] = $entity;
+			}
+		}
 
-        return $resultArray;
-    }
+		return $resultArray;
+	}
 
-    /**
-     * @return PHPFunction[]
-     * @throws RuntimeException
-     */
-    public static function getFilteredFunctions(PHPInterface|PHPClass $class = null, bool $shouldSuitCurrentPhpVersion = true): array
-    {
-        if ($class === null) {
-            $allFunctions = ReflectionStubsSingleton::getReflectionStubs()->getFunctions();
-        } else {
-            $allFunctions = $class->methods;
-        }
-        /** @var PHPFunction[] $resultArray */
-        $resultArray = [];
-        $allFunctions = array_filter(
-            $allFunctions,
-            fn ($function) => !$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function)
-        );
-        foreach (self::getFiltered($allFunctions, null, StubProblemType::HAS_DUPLICATION, StubProblemType::FUNCTION_PARAMETER_MISMATCH) as $function) {
-            $resultArray[] = $function;
-        }
-        return $resultArray;
-    }
+	/**
+	 * @return PHPFunction[]
+	 * @throws RuntimeException
+	 */
+	public static function getFilteredFunctions(PHPInterface|PHPClass $class = null, bool $shouldSuitCurrentPhpVersion = true): array
+	{
+		if ($class === null) {
+			$allFunctions = ReflectionStubsSingleton::getReflectionStubs()->getFunctions();
+		} else {
+			$allFunctions = $class->methods;
+		}
+		/** @var PHPFunction[] $resultArray */
+		$resultArray = [];
+		$allFunctions = array_filter(
+			$allFunctions,
+			fn ($function) => !$shouldSuitCurrentPhpVersion || BasePHPElement::entitySuitsCurrentPhpVersion($function)
+		);
+		foreach (self::getFiltered($allFunctions, null, StubProblemType::HAS_DUPLICATION, StubProblemType::FUNCTION_PARAMETER_MISMATCH) as $function) {
+			$resultArray[] = $function;
+		}
+		return $resultArray;
+	}
 
-    public static function getFilteredParameters(PHPFunction $function, callable $additionalFilter = null, int ...$problemType): array
-    {
-        /** @var PHPParameter[] $resultArray */
-        $resultArray = [];
-        foreach (self::getFiltered(
-            $function->parameters,
-            $additionalFilter,
-            StubProblemType::FUNCTION_PARAMETER_MISMATCH,
-            ...$problemType
-        ) as $parameter) {
-            $resultArray[] = $parameter;
-        }
-        return $resultArray;
-    }
+	public static function getFilteredParameters(PHPFunction $function, callable $additionalFilter = null, int ...$problemType): array
+	{
+		/** @var PHPParameter[] $resultArray */
+		$resultArray = [];
+		foreach (self::getFiltered(
+			$function->parameters,
+			$additionalFilter,
+			StubProblemType::FUNCTION_PARAMETER_MISMATCH,
+			...$problemType
+		) as $parameter) {
+			$resultArray[] = $parameter;
+		}
+		return $resultArray;
+	}
 
-    public static function getFilterFunctionForAllowedTypeHintsInLanguageLevel(float $languageVersion): callable
-    {
-        return function (PHPClass|PHPInterface $stubClass, PHPMethod $stubMethod, ?float $firstSinceVersion) use ($languageVersion) {
-            $reflectionClass = ReflectionStubsSingleton::getReflectionStubs()->getClass($stubClass->name);
-            $reflectionMethod = null;
-            if ($reflectionClass !== null) {
-                $reflectionMethods = array_filter(
-                    $reflectionClass->methods,
-                    fn (PHPMethod $method) => $stubMethod->name === $method->name
-                );
-                $reflectionMethod = array_pop($reflectionMethods);
-            }
-            return $reflectionMethod !== null && ($stubMethod->isFinal || $stubClass->isFinal || $firstSinceVersion !== null &&
-                    $firstSinceVersion > $languageVersion);
-        };
-    }
+	public static function getFilterFunctionForAllowedTypeHintsInLanguageLevel(float $languageVersion): callable
+	{
+		return function (PHPClass|PHPInterface $stubClass, PHPMethod $stubMethod, ?float $firstSinceVersion) use ($languageVersion) {
+			$reflectionClass = ReflectionStubsSingleton::getReflectionStubs()->getClass($stubClass->name);
+			$reflectionMethod = null;
+			if ($reflectionClass !== null) {
+				$reflectionMethods = array_filter(
+					$reflectionClass->methods,
+					fn (PHPMethod $method) => $stubMethod->name === $method->name
+				);
+				$reflectionMethod = array_pop($reflectionMethods);
+			}
+			return $reflectionMethod !== null && ($stubMethod->isFinal || $stubClass->isFinal || $firstSinceVersion !== null &&
+					$firstSinceVersion > $languageVersion);
+		};
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -46,7 +46,7 @@ 
      * @return PHPFunction[]
      * @throws RuntimeException
      */
-    public static function getFilteredFunctions(PHPInterface|PHPClass $class = null, bool $shouldSuitCurrentPhpVersion = true): array
+    public static function getFilteredFunctions(PHPInterface | PHPClass $class = null, bool $shouldSuitCurrentPhpVersion = true): array
     {
         if ($class === null) {
             $allFunctions = ReflectionStubsSingleton::getReflectionStubs()->getFunctions();
@@ -82,7 +82,7 @@ 
 
     public static function getFilterFunctionForAllowedTypeHintsInLanguageLevel(float $languageVersion): callable
     {
-        return function (PHPClass|PHPInterface $stubClass, PHPMethod $stubMethod, ?float $firstSinceVersion) use ($languageVersion) {
+        return function(PHPClass | PHPInterface $stubClass, PHPMethod $stubMethod, ?float $firstSinceVersion) use ($languageVersion) {
             $reflectionClass = ReflectionStubsSingleton::getReflectionStubs()->getClass($stubClass->name);
             $reflectionMethod = null;
             if ($reflectionClass !== null) {

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
 use StubTests\Model\PHPParameter;
 use StubTests\Model\StubProblemType;
 
-class EntitiesFilter
-{
+class EntitiesFilter {
     /**
      * @param BasePHPElement[] $entities
      * @return BasePHPElement[]

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/Stubs/StubsParametersProvider.php

Indentation +75 added lines, -75 removed lines

@@ -15,86 +15,86 @@
 
 class StubsParametersProvider
 {
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForScalarTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(7);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_HAS_SCALAR_TYPEHINT);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForScalarTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(7);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_HAS_SCALAR_TYPEHINT);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForNullableTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(7.1);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_NULLABLE_TYPEHINT);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForNullableTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(7.1);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_NULLABLE_TYPEHINT);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForUnionTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(8);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_UNION_TYPEHINT);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForUnionTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(8);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_UNION_TYPEHINT);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForAllowedScalarTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(7);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_TYPE_MISMATCH);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForAllowedScalarTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(7);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_TYPE_MISMATCH);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForAllowedNullableTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(7.1);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_TYPE_MISMATCH);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForAllowedNullableTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(7.1);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::PARAMETER_TYPE_MISMATCH);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function parametersForAllowedUnionTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(8);
-        return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_UNION_TYPEHINT);
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function parametersForAllowedUnionTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = EntitiesFilter::getFilterFunctionForAllowedTypeHintsInLanguageLevel(8);
+		return self::yieldFilteredMethodParameters($filterFunction, StubProblemType::HAS_UNION_TYPEHINT);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    private static function yieldFilteredMethodParameters(callable $filterFunction, int ...$problemTypes): ?Generator
-    {
-        $coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getCoreClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getCoreInterfaces();
-        foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $class) {
-            foreach (EntitiesFilter::getFilteredFunctions($class, false) as $method) {
-                foreach (EntitiesFilter::getFilteredParameters($method, null, ...$problemTypes) as $parameter) {
-                    if (!empty($parameter->availableVersionsRangeFromAttribute)) {
-                        $firstSinceVersion = max(ParserUtils::getDeclaredSinceVersion($method), min($parameter->availableVersionsRangeFromAttribute));
-                    } else {
-                        $firstSinceVersion = ParserUtils::getDeclaredSinceVersion($method);
-                    }
-                    if ($filterFunction($class, $method, $firstSinceVersion) === true) {
-                        yield "method $class->name::$method->name($parameter->name)" => [$class, $method, $parameter];
-                    }
-                }
-            }
-        }
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	private static function yieldFilteredMethodParameters(callable $filterFunction, int ...$problemTypes): ?Generator
+	{
+		$coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getCoreClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getCoreInterfaces();
+		foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $class) {
+			foreach (EntitiesFilter::getFilteredFunctions($class, false) as $method) {
+				foreach (EntitiesFilter::getFilteredParameters($method, null, ...$problemTypes) as $parameter) {
+					if (!empty($parameter->availableVersionsRangeFromAttribute)) {
+						$firstSinceVersion = max(ParserUtils::getDeclaredSinceVersion($method), min($parameter->availableVersionsRangeFromAttribute));
+					} else {
+						$firstSinceVersion = ParserUtils::getDeclaredSinceVersion($method);
+					}
+					if ($filterFunction($class, $method, $firstSinceVersion) === true) {
+						yield "method $class->name::$method->name($parameter->name)" => [$class, $method, $parameter];
+					}
+				}
+			}
+		}
+	}
 
-    private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
-    {
-        return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
-            !$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion;
-    }
+	private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
+	{
+		return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
+			!$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -94,7 +94,7 @@
 
     private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
     {
-        return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
+        return fn (PHPClass | PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
             !$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion;
     }
 }

Braces +1 added lines, -2 removed lines

@@ -13,8 +13,7 @@
 use StubTests\TestData\Providers\EntitiesFilter;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class StubsParametersProvider
-{
+class StubsParametersProvider {
     /**
      * @throws RuntimeException
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/Stubs/StubMethodsProvider.php

Indentation +98 added lines, -98 removed lines

@@ -16,108 +16,108 @@
 
 class StubMethodsProvider
 {
-    public static function allMethodsProvider(): ?Generator
-    {
-        $classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
-        foreach ($classesAndInterfaces as $className => $class) {
-            foreach ($class->methods as $methodName => $method) {
-                yield "method $className::$methodName" => [$method];
-            }
-        }
-    }
+	public static function allMethodsProvider(): ?Generator
+	{
+		$classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
+		foreach ($classesAndInterfaces as $className => $class) {
+			foreach ($class->methods as $methodName => $method) {
+				yield "method $className::$methodName" => [$method];
+			}
+		}
+	}
 
-    public static function allFunctionAndMethodsWithReturnTypeHintsProvider(): ?Generator
-    {
-        $coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
-        $allFunctions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
-        $filteredMethods = [];
-        foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $class) {
-            $filteredMethods = EntitiesFilter::getFiltered(
-                $class->methods,
-                fn (PHPMethod $method) => empty($method->returnTypesFromSignature) || empty($method->returnTypesFromPhpDoc)
-                    || $method->parentName === '___PHPSTORM_HELPERS\object',
-                StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE
-            );
-        }
-        $filteredMethods += EntitiesFilter::getFiltered(
-            $allFunctions,
-            fn (PHPFunction $function) => empty($function->returnTypesFromSignature) || empty($function->returnTypesFromPhpDoc),
-            StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE
-        );
-        foreach ($filteredMethods as $methodName => $method) {
-            if ($method instanceof PHPMethod) {
-                yield "method $method->parentName::$methodName" => [$method];
-            } else {
-                yield "function $methodName" => [$method];
-            }
-        }
-    }
+	public static function allFunctionAndMethodsWithReturnTypeHintsProvider(): ?Generator
+	{
+		$coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
+		$allFunctions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
+		$filteredMethods = [];
+		foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $class) {
+			$filteredMethods = EntitiesFilter::getFiltered(
+				$class->methods,
+				fn (PHPMethod $method) => empty($method->returnTypesFromSignature) || empty($method->returnTypesFromPhpDoc)
+					|| $method->parentName === '___PHPSTORM_HELPERS\object',
+				StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE
+			);
+		}
+		$filteredMethods += EntitiesFilter::getFiltered(
+			$allFunctions,
+			fn (PHPFunction $function) => empty($function->returnTypesFromSignature) || empty($function->returnTypesFromPhpDoc),
+			StubProblemType::TYPE_IN_PHPDOC_DIFFERS_FROM_SIGNATURE
+		);
+		foreach ($filteredMethods as $methodName => $method) {
+			if ($method instanceof PHPMethod) {
+				yield "method $method->parentName::$methodName" => [$method];
+			} else {
+				yield "function $methodName" => [$method];
+			}
+		}
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function methodsForReturnTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(7);
-        return self::yieldFilteredMethods(
-            $filterFunction,
-            StubProblemType::FUNCTION_HAS_RETURN_TYPEHINT,
-            StubProblemType::WRONG_RETURN_TYPEHINT
-        );
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function methodsForReturnTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(7);
+		return self::yieldFilteredMethods(
+			$filterFunction,
+			StubProblemType::FUNCTION_HAS_RETURN_TYPEHINT,
+			StubProblemType::WRONG_RETURN_TYPEHINT
+		);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function methodsForNullableReturnTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(7.1);
-        return self::yieldFilteredMethods(
-            $filterFunction,
-            StubProblemType::HAS_NULLABLE_TYPEHINT,
-            StubProblemType::WRONG_RETURN_TYPEHINT
-        );
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function methodsForNullableReturnTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(7.1);
+		return self::yieldFilteredMethods(
+			$filterFunction,
+			StubProblemType::HAS_NULLABLE_TYPEHINT,
+			StubProblemType::WRONG_RETURN_TYPEHINT
+		);
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public static function methodsForUnionReturnTypeHintTestsProvider(): ?Generator
-    {
-        $filterFunction = self::getFilterFunctionForLanguageLevel(8);
-        return self::yieldFilteredMethods(
-            $filterFunction,
-            StubProblemType::HAS_UNION_TYPEHINT,
-            StubProblemType::WRONG_RETURN_TYPEHINT
-        );
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public static function methodsForUnionReturnTypeHintTestsProvider(): ?Generator
+	{
+		$filterFunction = self::getFilterFunctionForLanguageLevel(8);
+		return self::yieldFilteredMethods(
+			$filterFunction,
+			StubProblemType::HAS_UNION_TYPEHINT,
+			StubProblemType::WRONG_RETURN_TYPEHINT
+		);
+	}
 
-    private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
-    {
-        return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
-            !$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion && !$method->isReturnTypeTentative;
-    }
+	private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
+	{
+		return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
+			!$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion && !$method->isReturnTypeTentative;
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    private static function yieldFilteredMethods(callable $filterFunction, int ...$problemTypes): ?Generator
-    {
-        $coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getCoreClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getCoreInterfaces();
-        foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $className => $class) {
-            foreach (EntitiesFilter::getFiltered(
-                $class->methods,
-                fn (PHPMethod $method) => $method->parentName === '___PHPSTORM_HELPERS\object',
-                ...$problemTypes
-            ) as $methodName => $method) {
-                $firstSinceVersion = ParserUtils::getDeclaredSinceVersion($method);
-                if ($filterFunction($class, $method, $firstSinceVersion) === true) {
-                    yield "method $className::$methodName" => [$method];
-                }
-            }
-        }
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	private static function yieldFilteredMethods(callable $filterFunction, int ...$problemTypes): ?Generator
+	{
+		$coreClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getCoreClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getCoreInterfaces();
+		foreach (EntitiesFilter::getFiltered($coreClassesAndInterfaces) as $className => $class) {
+			foreach (EntitiesFilter::getFiltered(
+				$class->methods,
+				fn (PHPMethod $method) => $method->parentName === '___PHPSTORM_HELPERS\object',
+				...$problemTypes
+			) as $methodName => $method) {
+				$firstSinceVersion = ParserUtils::getDeclaredSinceVersion($method);
+				if ($filterFunction($class, $method, $firstSinceVersion) === true) {
+					yield "method $className::$methodName" => [$method];
+				}
+			}
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -96,7 +96,7 @@
 
     private static function getFilterFunctionForLanguageLevel(float $languageVersion): callable
     {
-        return fn (PHPClass|PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
+        return fn (PHPClass | PHPInterface $class, PHPMethod $method, ?float $firstSinceVersion) => !$method->isFinal &&
             !$class->isFinal && $firstSinceVersion !== null && $firstSinceVersion < $languageVersion && !$method->isReturnTypeTentative;
     }
 

Braces +1 added lines, -2 removed lines

@@ -14,8 +14,7 @@
 use StubTests\TestData\Providers\EntitiesFilter;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class StubMethodsProvider
-{
+class StubMethodsProvider {
     public static function allMethodsProvider(): ?Generator
     {
         $classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/Stubs/StubsTestDataProviders.php

Indentation +34 added lines, -34 removed lines

@@ -13,41 +13,41 @@
 
 class StubsTestDataProviders
 {
-    public static function allFunctionsProvider(): ?Generator
-    {
-        foreach (PhpStormStubsSingleton::getPhpStormStubs()->getFunctions() as $functionName => $function) {
-            yield "function $functionName" => [$function];
-        }
-    }
+	public static function allFunctionsProvider(): ?Generator
+	{
+		foreach (PhpStormStubsSingleton::getPhpStormStubs()->getFunctions() as $functionName => $function) {
+			yield "function $functionName" => [$function];
+		}
+	}
 
-    public static function allClassesProvider(): ?Generator
-    {
-        $allClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
-        foreach ($allClassesAndInterfaces as $class) {
-            yield "class $class->sourceFilePath/$class->name" => [$class];
-        }
-    }
+	public static function allClassesProvider(): ?Generator
+	{
+		$allClassesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
+		foreach ($allClassesAndInterfaces as $class) {
+			yield "class $class->sourceFilePath/$class->name" => [$class];
+		}
+	}
 
-    public static function coreFunctionsProvider(): ?Generator
-    {
-        $allFunctions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
-        $coreFunctions = array_filter($allFunctions, fn (PHPFunction $function): bool => $function->stubBelongsToCore === true);
-        foreach ($coreFunctions as $coreFunction) {
-            yield "function $coreFunction->name" => [$coreFunction];
-        }
-    }
+	public static function coreFunctionsProvider(): ?Generator
+	{
+		$allFunctions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
+		$coreFunctions = array_filter($allFunctions, fn (PHPFunction $function): bool => $function->stubBelongsToCore === true);
+		foreach ($coreFunctions as $coreFunction) {
+			yield "function $coreFunction->name" => [$coreFunction];
+		}
+	}
 
-    public static function stubsDirectoriesProvider(): ?Generator
-    {
-        $stubsDirectory = dirname(__DIR__, 4);
-        /** @var SplFileInfo $directory */
-        foreach (new DirectoryIterator($stubsDirectory) as $directory) {
-            $directoryName = $directory->getBasename();
-            if ($directory->isDot() || !$directory->isDir() || in_array($directoryName, ['tests', 'meta', 'vendor'], true) || str_starts_with($directoryName, '.')) {
-                continue;
-            }
-            yield "directory $directoryName" => [$directoryName];
-        }
-    }
+	public static function stubsDirectoriesProvider(): ?Generator
+	{
+		$stubsDirectory = dirname(__DIR__, 4);
+		/** @var SplFileInfo $directory */
+		foreach (new DirectoryIterator($stubsDirectory) as $directory) {
+			$directoryName = $directory->getBasename();
+			if ($directory->isDot() || !$directory->isDir() || in_array($directoryName, ['tests', 'meta', 'vendor'], true) || str_starts_with($directoryName, '.')) {
+				continue;
+			}
+			yield "directory $directoryName" => [$directoryName];
+		}
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -11,8 +11,7 @@
 use function dirname;
 use function in_array;
 
-class StubsTestDataProviders
-{
+class StubsTestDataProviders {
     public static function allFunctionsProvider(): ?Generator
     {
         foreach (PhpStormStubsSingleton::getPhpStormStubs()->getFunctions() as $functionName => $function) {

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/Stubs/StubConstantsProvider.php

Indentation +16 added lines, -16 removed lines

@@ -8,21 +8,21 @@
 
 class StubConstantsProvider
 {
-    public static function classConstantProvider(): ?Generator
-    {
-        $classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
-            PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
-        foreach ($classesAndInterfaces as $class) {
-            foreach ($class->constants as $constant) {
-                yield "constant $class->sourceFilePath/$class->name::$constant->name" => [$class, $constant];
-            }
-        }
-    }
+	public static function classConstantProvider(): ?Generator
+	{
+		$classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +
+			PhpStormStubsSingleton::getPhpStormStubs()->getInterfaces();
+		foreach ($classesAndInterfaces as $class) {
+			foreach ($class->constants as $constant) {
+				yield "constant $class->sourceFilePath/$class->name::$constant->name" => [$class, $constant];
+			}
+		}
+	}
 
-    public static function globalConstantProvider(): ?Generator
-    {
-        foreach (PhpStormStubsSingleton::getPhpStormStubs()->getConstants() as $constantName => $constant) {
-            yield "constant $constantName" => [$constant];
-        }
-    }
+	public static function globalConstantProvider(): ?Generator
+	{
+		foreach (PhpStormStubsSingleton::getPhpStormStubs()->getConstants() as $constantName => $constant) {
+			yield "constant $constantName" => [$constant];
+		}
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -6,8 +6,7 @@
 use Generator;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class StubConstantsProvider
-{
+class StubConstantsProvider {
     public static function classConstantProvider(): ?Generator
     {
         $classesAndInterfaces = PhpStormStubsSingleton::getPhpStormStubs()->getClasses() +

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/TestData/Providers/Stubs/PhpCoreStubsProvider.php

Indentation +210 added lines, -210 removed lines

@@ -7,216 +7,216 @@
 
 class PhpCoreStubsProvider
 {
-    public static array $StubDirectoryMap = [
-        'CORE' => [
-            'Core',
-            'date',
-            'filter',
-            'fpm',
-            'hash',
-            'meta',
-            'pcre',
-            'Phar',
-            'Reflection',
-            'regex',
-            'session',
-            'SPL',
-            'standard',
-            'superglobals',
-            'tokenizer'
-        ],
-        'BUNDLED' => [
-            'apache',
-            'bcmath',
-            'calendar',
-            'ctype',
-            'dba',
-            'exif',
-            'fileinfo',
-            'ftp',
-            'gd',
-            'iconv',
-            'intl',
-            'json',
-            'mbstring',
-            'pcntl',
-            'PDO',
-            'posix',
-            'shmop',
-            'sockets',
-            'sqlite3',
-            'sysvmsg',
-            'sysvsem',
-            'sysvshm',
-            'xmlrpc',
-            'zlib'
-        ],
-        'EXTERNAL' => [
-            'aerospike',
-            'bz2',
-            'curl',
-            'dom',
-            'enchant',
-            'gettext',
-            'gmp',
-            'imap',
-            'interbase',
-            'ldap',
-            'libxml',
-            'mcrypt',
-            'mssql',
-            'mysql',
-            'mysqli',
-            'oci8',
-            'odbc',
-            'openssl',
-            'pdo_ibm',
-            'pdo_mysql',
-            'pdo_pgsql',
-            'pdo_sqlite',
-            'pgsql',
-            'pspell',
-            'readline',
-            'recode',
-            'SimpleXML',
-            'snmp',
-            'soap',
-            'sodium',
-            'sybase',
-            'tidy',
-            'wddx',
-            'xml',
-            'xmlreader',
-            'xmlwriter',
-            'xsl',
-            'Zend OPcache',
-            'zip'
-        ],
-        'PECL' => [
-            'apcu',
-            'ast',
-            'crypto',
-            'cubrid',
-            'decimal',
-            'ds',
-            'event',
-            'expect',
-            'gearman',
-            'geoip',
-            'gmagick',
-            'http',
-            'ibm_db2',
-            'imagick',
-            'inotify',
-            'leveldb',
-            'libevent',
-            'LuaSandbox',
-            'lzf',
-            'mailparse',
-            'memcache',
-            'memcached',
-            'ming',
-            'mongo',
-            'mongodb',
-            'msgpack',
-            'mysql_xdevapi',
-            'ncurses',
-            'oauth',
-            'parallel',
-            'Parle',
-            'pcov',
-            'pdflib',
-            'pq',
-            'pthreads',
-            'radius',
-            'rdkafka',
-            'rpminfo',
-            'solr',
-            'SplType',
-            'SQLite',
-            'sqlsrv',
-            'ssh2',
-            'stats',
-            'stomp',
-            'svn',
-            'sync',
-            'uopz',
-            'uuid',
-            'uv',
-            'winbinder',
-            'wincache',
-            'xdiff',
-            'xhprof',
-            'xxtea',
-            'yaf',
-            'yaml',
-            'yar',
-            'zookeeper',
-            'zstd'
-        ],
-        'OTHERS' => [
-            'amqp',
-            'blackfire',
-            'cassandra',
-            'com_dotnet',
-            'couchbase',
-            'couchbase_v2',
-            'dio',
-            'Ev',
-            'fann',
-            'FFI',
-            'ffmpeg',
-            'geos',
-            'gnupg',
-            'grpc',
-            'igbinary',
-            'judy',
-            'libsodium',
-            'libvirt-php',
-            'lua',
-            'mapscript',
-            'meminfo',
-            'mosquitto-php',
-            'mqseries',
-            'newrelic',
-            'phpdbg',
-            'rar',
-            'redis',
-            'rrd',
-            'SaxonC',
-            'suhosin',
-            'svm',
-            'v8js',
-            'win32service',
-            'xcache',
-            'xdebug',
-            'xlswriter',
-            'zend',
-            'ZendCache',
-            'ZendDebugger',
-            'ZendUtils',
-            'zmq'
-        ]
-    ];
+	public static array $StubDirectoryMap = [
+		'CORE' => [
+			'Core',
+			'date',
+			'filter',
+			'fpm',
+			'hash',
+			'meta',
+			'pcre',
+			'Phar',
+			'Reflection',
+			'regex',
+			'session',
+			'SPL',
+			'standard',
+			'superglobals',
+			'tokenizer'
+		],
+		'BUNDLED' => [
+			'apache',
+			'bcmath',
+			'calendar',
+			'ctype',
+			'dba',
+			'exif',
+			'fileinfo',
+			'ftp',
+			'gd',
+			'iconv',
+			'intl',
+			'json',
+			'mbstring',
+			'pcntl',
+			'PDO',
+			'posix',
+			'shmop',
+			'sockets',
+			'sqlite3',
+			'sysvmsg',
+			'sysvsem',
+			'sysvshm',
+			'xmlrpc',
+			'zlib'
+		],
+		'EXTERNAL' => [
+			'aerospike',
+			'bz2',
+			'curl',
+			'dom',
+			'enchant',
+			'gettext',
+			'gmp',
+			'imap',
+			'interbase',
+			'ldap',
+			'libxml',
+			'mcrypt',
+			'mssql',
+			'mysql',
+			'mysqli',
+			'oci8',
+			'odbc',
+			'openssl',
+			'pdo_ibm',
+			'pdo_mysql',
+			'pdo_pgsql',
+			'pdo_sqlite',
+			'pgsql',
+			'pspell',
+			'readline',
+			'recode',
+			'SimpleXML',
+			'snmp',
+			'soap',
+			'sodium',
+			'sybase',
+			'tidy',
+			'wddx',
+			'xml',
+			'xmlreader',
+			'xmlwriter',
+			'xsl',
+			'Zend OPcache',
+			'zip'
+		],
+		'PECL' => [
+			'apcu',
+			'ast',
+			'crypto',
+			'cubrid',
+			'decimal',
+			'ds',
+			'event',
+			'expect',
+			'gearman',
+			'geoip',
+			'gmagick',
+			'http',
+			'ibm_db2',
+			'imagick',
+			'inotify',
+			'leveldb',
+			'libevent',
+			'LuaSandbox',
+			'lzf',
+			'mailparse',
+			'memcache',
+			'memcached',
+			'ming',
+			'mongo',
+			'mongodb',
+			'msgpack',
+			'mysql_xdevapi',
+			'ncurses',
+			'oauth',
+			'parallel',
+			'Parle',
+			'pcov',
+			'pdflib',
+			'pq',
+			'pthreads',
+			'radius',
+			'rdkafka',
+			'rpminfo',
+			'solr',
+			'SplType',
+			'SQLite',
+			'sqlsrv',
+			'ssh2',
+			'stats',
+			'stomp',
+			'svn',
+			'sync',
+			'uopz',
+			'uuid',
+			'uv',
+			'winbinder',
+			'wincache',
+			'xdiff',
+			'xhprof',
+			'xxtea',
+			'yaf',
+			'yaml',
+			'yar',
+			'zookeeper',
+			'zstd'
+		],
+		'OTHERS' => [
+			'amqp',
+			'blackfire',
+			'cassandra',
+			'com_dotnet',
+			'couchbase',
+			'couchbase_v2',
+			'dio',
+			'Ev',
+			'fann',
+			'FFI',
+			'ffmpeg',
+			'geos',
+			'gnupg',
+			'grpc',
+			'igbinary',
+			'judy',
+			'libsodium',
+			'libvirt-php',
+			'lua',
+			'mapscript',
+			'meminfo',
+			'mosquitto-php',
+			'mqseries',
+			'newrelic',
+			'phpdbg',
+			'rar',
+			'redis',
+			'rrd',
+			'SaxonC',
+			'suhosin',
+			'svm',
+			'v8js',
+			'win32service',
+			'xcache',
+			'xdebug',
+			'xlswriter',
+			'zend',
+			'ZendCache',
+			'ZendDebugger',
+			'ZendUtils',
+			'zmq'
+		]
+	];
 
-    /**
-     * @return string[]
-     */
-    public static function getCoreStubsDirectories(): array
-    {
-        $coreStubs = [self::$StubDirectoryMap['CORE']];
-        $coreStubs[] = self::$StubDirectoryMap['BUNDLED'];
-        $coreStubs[] = self::$StubDirectoryMap['EXTERNAL'];
-        return CommonUtils::flattenArray($coreStubs, false);
-    }
+	/**
+	 * @return string[]
+	 */
+	public static function getCoreStubsDirectories(): array
+	{
+		$coreStubs = [self::$StubDirectoryMap['CORE']];
+		$coreStubs[] = self::$StubDirectoryMap['BUNDLED'];
+		$coreStubs[] = self::$StubDirectoryMap['EXTERNAL'];
+		return CommonUtils::flattenArray($coreStubs, false);
+	}
 
-    /**
-     * @return string[]
-     */
-    public static function getNonCoreStubsDirectories(): array
-    {
-        $coreStubs = [self::$StubDirectoryMap['PECL']];
-        $coreStubs[] = self::$StubDirectoryMap['OTHERS'];
-        return CommonUtils::flattenArray($coreStubs, false);
-    }
+	/**
+	 * @return string[]
+	 */
+	public static function getNonCoreStubsDirectories(): array
+	{
+		$coreStubs = [self::$StubDirectoryMap['PECL']];
+		$coreStubs[] = self::$StubDirectoryMap['OTHERS'];
+		return CommonUtils::flattenArray($coreStubs, false);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -5,8 +5,7 @@
 
 use StubTests\Model\CommonUtils;
 
-class PhpCoreStubsProvider
-{
+class PhpCoreStubsProvider {
     public static array $StubDirectoryMap = [
         'CORE' => [
             'Core',

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/StubsReflectionClassesTest.php

Indentation +62 added lines, -62 removed lines

@@ -12,68 +12,68 @@
  */
 class StubsReflectionClassesTest extends BaseStubsTest
 {
-    /**
-     * @throws Exception|RuntimeException
-     */
-    public function testReflectionFunctionAbstractGetReturnTypeMethod()
-    {
-        $getReturnTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionFunctionAbstract')->getMethod('getReturnType');
-        $allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getReturnTypeMethod->returnTypesFromAttribute +
-            $getReturnTypeMethod->returnTypesFromSignature + $getReturnTypeMethod->returnTypesFromPhpDoc, false));
-        self::assertContains(
-            'ReflectionNamedType',
-            $allReturnTypes,
-            'method ReflectionFunctionAbstract::getReturnType should have ReflectionNamedType in return types for php 7.1+'
-        );
-        self::assertContains(
-            'ReflectionUnionType',
-            $allReturnTypes,
-            'method ReflectionFunctionAbstract::getReturnType should have ReflectionUnionType in return types for php 8.0+'
-        );
-        self::assertContains(
-            'ReflectionType',
-            $allReturnTypes,
-            'method ReflectionFunctionAbstract::getReturnType should have ReflectionType in return types for php 7.0'
-        );
-    }
+	/**
+	 * @throws Exception|RuntimeException
+	 */
+	public function testReflectionFunctionAbstractGetReturnTypeMethod()
+	{
+		$getReturnTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionFunctionAbstract')->getMethod('getReturnType');
+		$allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getReturnTypeMethod->returnTypesFromAttribute +
+			$getReturnTypeMethod->returnTypesFromSignature + $getReturnTypeMethod->returnTypesFromPhpDoc, false));
+		self::assertContains(
+			'ReflectionNamedType',
+			$allReturnTypes,
+			'method ReflectionFunctionAbstract::getReturnType should have ReflectionNamedType in return types for php 7.1+'
+		);
+		self::assertContains(
+			'ReflectionUnionType',
+			$allReturnTypes,
+			'method ReflectionFunctionAbstract::getReturnType should have ReflectionUnionType in return types for php 8.0+'
+		);
+		self::assertContains(
+			'ReflectionType',
+			$allReturnTypes,
+			'method ReflectionFunctionAbstract::getReturnType should have ReflectionType in return types for php 7.0'
+		);
+	}
 
-    /**
-     * @throws Exception|RuntimeException
-     */
-    public function testReflectionPropertyGetTypeMethod()
-    {
-        $getTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionProperty')->getMethod('getType');
-        $allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getTypeMethod->returnTypesFromAttribute +
-            $getTypeMethod->returnTypesFromSignature + $getTypeMethod->returnTypesFromPhpDoc, false));
-        self::assertContains(
-            'ReflectionNamedType',
-            $allReturnTypes,
-            'method ReflectionProperty::getType should have ReflectionNamedType in return types for php 7.1+'
-        );
-        self::assertContains(
-            'ReflectionUnionType',
-            $allReturnTypes,
-            'method ReflectionProperty::getType should have ReflectionUnionType in return types for php 8.0+'
-        );
-    }
+	/**
+	 * @throws Exception|RuntimeException
+	 */
+	public function testReflectionPropertyGetTypeMethod()
+	{
+		$getTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionProperty')->getMethod('getType');
+		$allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getTypeMethod->returnTypesFromAttribute +
+			$getTypeMethod->returnTypesFromSignature + $getTypeMethod->returnTypesFromPhpDoc, false));
+		self::assertContains(
+			'ReflectionNamedType',
+			$allReturnTypes,
+			'method ReflectionProperty::getType should have ReflectionNamedType in return types for php 7.1+'
+		);
+		self::assertContains(
+			'ReflectionUnionType',
+			$allReturnTypes,
+			'method ReflectionProperty::getType should have ReflectionUnionType in return types for php 8.0+'
+		);
+	}
 
-    /**
-     * @throws Exception|RuntimeException
-     */
-    public function testReflectionParameterGetTypeMethod()
-    {
-        $getTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionParameter')->getMethod('getType');
-        $allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getTypeMethod->returnTypesFromAttribute +
-            $getTypeMethod->returnTypesFromSignature + $getTypeMethod->returnTypesFromPhpDoc, false));
-        self::assertContains(
-            'ReflectionNamedType',
-            $allReturnTypes,
-            'method ReflectionParameter::getType should have ReflectionNamedType in return types'
-        );
-        self::assertContains(
-            'ReflectionUnionType',
-            $allReturnTypes,
-            'method ReflectionParameter::getType should have ReflectionUnionType in return types'
-        );
-    }
+	/**
+	 * @throws Exception|RuntimeException
+	 */
+	public function testReflectionParameterGetTypeMethod()
+	{
+		$getTypeMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass('ReflectionParameter')->getMethod('getType');
+		$allReturnTypes = array_unique(Model\CommonUtils::flattenArray($getTypeMethod->returnTypesFromAttribute +
+			$getTypeMethod->returnTypesFromSignature + $getTypeMethod->returnTypesFromPhpDoc, false));
+		self::assertContains(
+			'ReflectionNamedType',
+			$allReturnTypes,
+			'method ReflectionParameter::getType should have ReflectionNamedType in return types'
+		);
+		self::assertContains(
+			'ReflectionUnionType',
+			$allReturnTypes,
+			'method ReflectionParameter::getType should have ReflectionUnionType in return types'
+		);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -10,8 +10,7 @@
 /**
  * Class to test typehints of some Reflection* classes as reflection for these classes returns null.
  */
-class StubsReflectionClassesTest extends BaseStubsTest
-{
+class StubsReflectionClassesTest extends BaseStubsTest {
     /**
      * @throws Exception|RuntimeException
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/StubsStructureTest.php

Indentation +13 added lines, -13 removed lines

@@ -8,17 +8,17 @@
 
 class StubsStructureTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsTestDataProviders::stubsDirectoriesProvider
-     */
-    public function testStubsDirectoryExistInMap($directory)
-    {
-        self::assertContains(
-            $directory,
-            iterator_to_array(new RecursiveIteratorIterator(
-                new RecursiveArrayIterator(PhpCoreStubsProvider::$StubDirectoryMap)
-            ), false),
-            "Stubs directories provider doesn't contain '$directory'. Please add '$directory' to 'PhpCoreStubsProvider::\%StubDirectoryMap'"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsTestDataProviders::stubsDirectoriesProvider
+	 */
+	public function testStubsDirectoryExistInMap($directory)
+	{
+		self::assertContains(
+			$directory,
+			iterator_to_array(new RecursiveIteratorIterator(
+				new RecursiveArrayIterator(PhpCoreStubsProvider::$StubDirectoryMap)
+			), false),
+			"Stubs directories provider doesn't contain '$directory'. Please add '$directory' to 'PhpCoreStubsProvider::\%StubDirectoryMap'"
+		);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -6,8 +6,7 @@
 use RecursiveIteratorIterator;
 use StubTests\TestData\Providers\Stubs\PhpCoreStubsProvider;
 
-class StubsStructureTest extends BaseStubsTest
-{
+class StubsStructureTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsTestDataProviders::stubsDirectoriesProvider
      */

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/StubsPhp81Tests.php

Indentation +60 added lines, -60 removed lines

@@ -11,65 +11,65 @@
 
 class StubsPhp81Tests extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classReadonlyPropertiesProvider
-     * @throws RuntimeException
-     */
-    public function testPropertyReadonly(PHPClass $class, PHPProperty $property)
-    {
-        $className = $class->name;
-        $stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
-        static::assertEquals(
-            $property->isReadonly,
-            $stubProperty->isReadonly,
-            "Property $className::$property->name readonly modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classReadonlyPropertiesProvider
+	 * @throws RuntimeException
+	 */
+	public function testPropertyReadonly(PHPClass $class, PHPProperty $property)
+	{
+		$className = $class->name;
+		$stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
+		static::assertEquals(
+			$property->isReadonly,
+			$stubProperty->isReadonly,
+			"Property $className::$property->name readonly modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithTentitiveReturnTypeProvider
-     * @throws RuntimeException
-     */
-    public function testTentativeReturnTypeHints(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $functionName = $method->name;
-        if ($class instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($functionName);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($functionName);
-        }
-        $unifiedStubsReturnTypes = [];
-        $unifiedStubsAttributesReturnTypes = [];
-        $unifiedReflectionReturnTypes = [];
-        self::convertNullableTypesToUnion($method->returnTypesFromSignature, $unifiedReflectionReturnTypes);
-        if (!empty($stubMethod->returnTypesFromSignature)) {
-            self::convertNullableTypesToUnion($stubMethod->returnTypesFromSignature, $unifiedStubsReturnTypes);
-        } else {
-            foreach ($stubMethod->returnTypesFromAttribute as $languageVersion => $listOfTypes) {
-                $unifiedStubsAttributesReturnTypes[$languageVersion] = [];
-                self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesReturnTypes[$languageVersion]);
-            }
-        }
-        $conditionToCompareWithSignature = BaseStubsTest::isReflectionTypesMatchSignature(
-            $unifiedReflectionReturnTypes,
-            $unifiedStubsReturnTypes
-        );
-        $typesFromAttribute = [];
-        if (!empty($unifiedStubsAttributesReturnTypes)) {
-            $typesFromAttribute = !empty($unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')]) ?
-                $unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')] :
-                $unifiedStubsAttributesReturnTypes['default'];
-        }
-        $conditionToCompareWithAttribute = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionReturnTypes, $typesFromAttribute);
-        $testCondition = $conditionToCompareWithSignature || $conditionToCompareWithAttribute;
-        self::assertTrue(
-            $testCondition,
-            "Method $class->name::$functionName has invalid return type. Reflection method has return type " .
-            implode('|', $method->returnTypesFromSignature) .
-            ' but stubs has return type ' . implode('|', $stubMethod->returnTypesFromSignature) .
-            ' in signature and attribute has types ' . implode('|', $typesFromAttribute)
-        );
-        self::assertTrue($stubMethod->isReturnTypeTentative, "Reflection method $class->name::$functionName has " .
-            "tentative return type but stub's method isn't declared as tentative");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithTentitiveReturnTypeProvider
+	 * @throws RuntimeException
+	 */
+	public function testTentativeReturnTypeHints(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$functionName = $method->name;
+		if ($class instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($functionName);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($functionName);
+		}
+		$unifiedStubsReturnTypes = [];
+		$unifiedStubsAttributesReturnTypes = [];
+		$unifiedReflectionReturnTypes = [];
+		self::convertNullableTypesToUnion($method->returnTypesFromSignature, $unifiedReflectionReturnTypes);
+		if (!empty($stubMethod->returnTypesFromSignature)) {
+			self::convertNullableTypesToUnion($stubMethod->returnTypesFromSignature, $unifiedStubsReturnTypes);
+		} else {
+			foreach ($stubMethod->returnTypesFromAttribute as $languageVersion => $listOfTypes) {
+				$unifiedStubsAttributesReturnTypes[$languageVersion] = [];
+				self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesReturnTypes[$languageVersion]);
+			}
+		}
+		$conditionToCompareWithSignature = BaseStubsTest::isReflectionTypesMatchSignature(
+			$unifiedReflectionReturnTypes,
+			$unifiedStubsReturnTypes
+		);
+		$typesFromAttribute = [];
+		if (!empty($unifiedStubsAttributesReturnTypes)) {
+			$typesFromAttribute = !empty($unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')]) ?
+				$unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')] :
+				$unifiedStubsAttributesReturnTypes['default'];
+		}
+		$conditionToCompareWithAttribute = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionReturnTypes, $typesFromAttribute);
+		$testCondition = $conditionToCompareWithSignature || $conditionToCompareWithAttribute;
+		self::assertTrue(
+			$testCondition,
+			"Method $class->name::$functionName has invalid return type. Reflection method has return type " .
+			implode('|', $method->returnTypesFromSignature) .
+			' but stubs has return type ' . implode('|', $stubMethod->returnTypesFromSignature) .
+			' in signature and attribute has types ' . implode('|', $typesFromAttribute)
+		);
+		self::assertTrue($stubMethod->isReturnTypeTentative, "Reflection method $class->name::$functionName has " .
+			"tentative return type but stub's method isn't declared as tentative");
+	}
 }

Spacing +7 added lines, -8 removed lines

@@ -30,7 +30,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithTentitiveReturnTypeProvider
      * @throws RuntimeException
      */
-    public function testTentativeReturnTypeHints(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testTentativeReturnTypeHints(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $functionName = $method->name;
         if ($class instanceof PHPClass) {
@@ -57,19 +57,18 @@ 
         $typesFromAttribute = [];
         if (!empty($unifiedStubsAttributesReturnTypes)) {
             $typesFromAttribute = !empty($unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')]) ?
-                $unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')] :
-                $unifiedStubsAttributesReturnTypes['default'];
+                $unifiedStubsAttributesReturnTypes[getenv('PHP_VERSION')] : $unifiedStubsAttributesReturnTypes['default'];
         }
         $conditionToCompareWithAttribute = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionReturnTypes, $typesFromAttribute);
         $testCondition = $conditionToCompareWithSignature || $conditionToCompareWithAttribute;
         self::assertTrue(
             $testCondition,
-            "Method $class->name::$functionName has invalid return type. Reflection method has return type " .
-            implode('|', $method->returnTypesFromSignature) .
-            ' but stubs has return type ' . implode('|', $stubMethod->returnTypesFromSignature) .
-            ' in signature and attribute has types ' . implode('|', $typesFromAttribute)
+            "Method $class->name::$functionName has invalid return type. Reflection method has return type ".
+            implode('|', $method->returnTypesFromSignature).
+            ' but stubs has return type '.implode('|', $stubMethod->returnTypesFromSignature).
+            ' in signature and attribute has types '.implode('|', $typesFromAttribute)
         );
-        self::assertTrue($stubMethod->isReturnTypeTentative, "Reflection method $class->name::$functionName has " .
+        self::assertTrue($stubMethod->isReturnTypeTentative, "Reflection method $class->name::$functionName has ".
             "tentative return type but stub's method isn't declared as tentative");
     }
 }

Braces +1 added lines, -2 removed lines

@@ -9,8 +9,7 @@
 use StubTests\Model\PHPProperty;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class StubsPhp81Tests extends BaseStubsTest
-{
+class StubsPhp81Tests extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classReadonlyPropertiesProvider
      * @throws RuntimeException