nextcloud / fulltextsearch_elasticsearch

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

Indentation +144 added lines, -144 removed lines

@@ -17,157 +17,157 @@
 
 class BaseFunctionsTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testFunctionsExist(PHPFunction $function): void
-    {
-        $functionName = $function->name;
-        $stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
-        $params = BaseStubsTest::getParameterRepresentation($function);
-        static::assertNotEmpty($stubFunction, "Missing function: function $functionName($params){}");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testFunctionsExist(PHPFunction $function): void
+	{
+		$functionName = $function->name;
+		$stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
+		$params = BaseStubsTest::getParameterRepresentation($function);
+		static::assertNotEmpty($stubFunction, "Missing function: function $functionName($params){}");
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::functionsForDeprecationTestsProvider
-     * @throws RuntimeException
-     */
-    public function testFunctionsDeprecation(PHPFunction $function)
-    {
-        $functionName = $function->name;
-        $stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
-        static::assertFalse(
-            $function->is_deprecated && $stubFunction->is_deprecated !== true,
-            "Function $functionName is not deprecated in stubs"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::functionsForDeprecationTestsProvider
+	 * @throws RuntimeException
+	 */
+	public function testFunctionsDeprecation(PHPFunction $function)
+	{
+		$functionName = $function->name;
+		$stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
+		static::assertFalse(
+			$function->is_deprecated && $stubFunction->is_deprecated !== true,
+			"Function $functionName is not deprecated in stubs"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::functionsForParamsAmountTestsProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testFunctionsParametersAmount(PHPFunction $function)
-    {
-        $functionName = $function->name;
-        $stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
-        $filteredStubParameters = array_filter(
-            $stubFunction->parameters,
-            fn ($parameter) => BasePHPElement::entitySuitsCurrentPhpVersion($parameter)
-        );
-        $uniqueParameterNames = array_unique(array_map(fn (PHPParameter $parameter) => $parameter->name, $filteredStubParameters));
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::functionsForParamsAmountTestsProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testFunctionsParametersAmount(PHPFunction $function)
+	{
+		$functionName = $function->name;
+		$stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
+		$filteredStubParameters = array_filter(
+			$stubFunction->parameters,
+			fn ($parameter) => BasePHPElement::entitySuitsCurrentPhpVersion($parameter)
+		);
+		$uniqueParameterNames = array_unique(array_map(fn (PHPParameter $parameter) => $parameter->name, $filteredStubParameters));
 
-        static::assertSameSize(
-            $function->parameters,
-            $uniqueParameterNames,
-            "Parameter number mismatch for function $functionName. 
+		static::assertSameSize(
+			$function->parameters,
+			$uniqueParameterNames,
+			"Parameter number mismatch for function $functionName. 
                 Expected: " . BaseStubsTest::getParameterRepresentation($function) . "\n" .
-            'Actual: ' . BaseStubsTest::getParameterRepresentation($stubFunction)
-        );
-    }
+			'Actual: ' . BaseStubsTest::getParameterRepresentation($stubFunction)
+		);
+	}
 
-    /**
-     * @throws Exception|RuntimeException
-     */
-    public function testFunctionsDuplicates()
-    {
-        $filtered = EntitiesFilter::getFiltered(
-            PhpStormStubsSingleton::getPhpStormStubs()->getFunctions(),
-            problemTypes: StubProblemType::HAS_DUPLICATION
-        );
-        $duplicates = self::getDuplicatedFunctions($filtered);
-        self::assertCount(
-            0,
-            $duplicates,
-            "Functions \"" . implode(', ', $duplicates) .
-            "\" have duplicates in stubs.\nPlease use #[LanguageLevelTypeAware] or #[PhpStormStubsElementAvailable] if possible"
-        );
-    }
+	/**
+	 * @throws Exception|RuntimeException
+	 */
+	public function testFunctionsDuplicates()
+	{
+		$filtered = EntitiesFilter::getFiltered(
+			PhpStormStubsSingleton::getPhpStormStubs()->getFunctions(),
+			problemTypes: StubProblemType::HAS_DUPLICATION
+		);
+		$duplicates = self::getDuplicatedFunctions($filtered);
+		self::assertCount(
+			0,
+			$duplicates,
+			"Functions \"" . implode(', ', $duplicates) .
+			"\" have duplicates in stubs.\nPlease use #[LanguageLevelTypeAware] or #[PhpStormStubsElementAvailable] if possible"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionParametersProvider
-     * @throws RuntimeException
-     */
-    public function testFunctionsOptionalParameters(PHPFunction $function, PHPParameter $parameter)
-    {
-        $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($function->name);
-        $stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
-        /** @var PHPParameter $stubOptionalParameter */
-        $stubOptionalParameter = array_pop($stubParameters);
-        self::assertEquals(
-            $parameter->isOptional,
-            $stubOptionalParameter->isOptional,
-            sprintf(
-                'Reflection function %s %s optional parameter %s with index %d 
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionParametersProvider
+	 * @throws RuntimeException
+	 */
+	public function testFunctionsOptionalParameters(PHPFunction $function, PHPParameter $parameter)
+	{
+		$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($function->name);
+		$stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
+		/** @var PHPParameter $stubOptionalParameter */
+		$stubOptionalParameter = array_pop($stubParameters);
+		self::assertEquals(
+			$parameter->isOptional,
+			$stubOptionalParameter->isOptional,
+			sprintf(
+				'Reflection function %s %s optional parameter %s with index %d 
             but stubs parameter %s with index %d %s',
-                $function->name,
-                $parameter->isOptional ? 'has' : 'has no',
-                $parameter->name,
-                $parameter->indexInSignature,
-                $stubOptionalParameter->name,
-                $stubOptionalParameter->indexInSignature,
-                $stubOptionalParameter->isOptional ? 'is optional' : 'is not optional'
-            )
-        );
-    }
+				$function->name,
+				$parameter->isOptional ? 'has' : 'has no',
+				$parameter->name,
+				$parameter->indexInSignature,
+				$stubOptionalParameter->name,
+				$stubOptionalParameter->indexInSignature,
+				$stubOptionalParameter->isOptional ? 'is optional' : 'is not optional'
+			)
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersProvider
-     * @throws RuntimeException
-     */
-    public function testMethodsOptionalParameters(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
-    {
-        if ($class instanceof PHPClass) {
-            $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);
-        } else {
-            $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($method->name);
-        }
-        $stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
-        /** @var PHPParameter $stubOptionalParameter */
-        $stubOptionalParameter = array_pop($stubParameters);
-        self::assertEquals(
-            $parameter->isOptional,
-            $stubOptionalParameter->isOptional,
-            sprintf(
-                'Reflection method %s::%s has optional parameter %s with index %d but stub parameter %s with index %d is not optional',
-                $class->name,
-                $method->name,
-                $parameter->name,
-                $parameter->indexInSignature,
-                $stubOptionalParameter->name,
-                $stubOptionalParameter->indexInSignature
-            )
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodsOptionalParameters(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
+	{
+		if ($class instanceof PHPClass) {
+			$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);
+		} else {
+			$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($method->name);
+		}
+		$stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
+		/** @var PHPParameter $stubOptionalParameter */
+		$stubOptionalParameter = array_pop($stubParameters);
+		self::assertEquals(
+			$parameter->isOptional,
+			$stubOptionalParameter->isOptional,
+			sprintf(
+				'Reflection method %s::%s has optional parameter %s with index %d but stub parameter %s with index %d is not optional',
+				$class->name,
+				$method->name,
+				$parameter->name,
+				$parameter->indexInSignature,
+				$stubOptionalParameter->name,
+				$stubOptionalParameter->indexInSignature
+			)
+		);
+	}
 
-    /**
-     * @throws Exception
-     */
-    public function testImplodeFunctionIsCorrect()
-    {
-        $implodeFunctions = array_filter(
-            PhpStormStubsSingleton::getPhpStormStubs()->getFunctions(),
-            fn (PHPFunction $function) => $function->name === 'implode'
-        );
-        self::assertCount(1, $implodeFunctions);
-        /** @var PHPFunction $implodeFunction */
-        $implodeFunction = array_pop($implodeFunctions);
-        $implodeParameters = $implodeFunction->parameters;
-        $separatorParameters = array_filter($implodeParameters, fn (PHPParameter $parameter) => $parameter->name === 'separator');
-        $arrayParameters = array_filter($implodeParameters, fn (PHPParameter $parameter) => $parameter->name === 'array');
-        /** @var PHPParameter $separatorParameter */
-        $separatorParameter = array_pop($separatorParameters);
-        /** @var PHPParameter $arrayParameter */
-        $arrayParameter = array_pop($arrayParameters);
-        self::assertCount(2, $implodeParameters);
-        self::assertEquals(['array', 'string'], $separatorParameter->typesFromSignature);
-        if (property_exists($separatorParameter->defaultValue, 'value')) {
-            self::assertEquals('', $separatorParameter->defaultValue->value);
-        } else {
-            self::fail("Couldn't read default value");
-        }
-        self::assertEquals(['?array'], $arrayParameter->typesFromSignature);
-        self::assertEquals(['string'], $implodeFunction->returnTypesFromSignature);
-        self::assertEquals(['string'], $implodeFunction->returnTypesFromPhpDoc);
-    }
+	/**
+	 * @throws Exception
+	 */
+	public function testImplodeFunctionIsCorrect()
+	{
+		$implodeFunctions = array_filter(
+			PhpStormStubsSingleton::getPhpStormStubs()->getFunctions(),
+			fn (PHPFunction $function) => $function->name === 'implode'
+		);
+		self::assertCount(1, $implodeFunctions);
+		/** @var PHPFunction $implodeFunction */
+		$implodeFunction = array_pop($implodeFunctions);
+		$implodeParameters = $implodeFunction->parameters;
+		$separatorParameters = array_filter($implodeParameters, fn (PHPParameter $parameter) => $parameter->name === 'separator');
+		$arrayParameters = array_filter($implodeParameters, fn (PHPParameter $parameter) => $parameter->name === 'array');
+		/** @var PHPParameter $separatorParameter */
+		$separatorParameter = array_pop($separatorParameters);
+		/** @var PHPParameter $arrayParameter */
+		$arrayParameter = array_pop($arrayParameters);
+		self::assertCount(2, $implodeParameters);
+		self::assertEquals(['array', 'string'], $separatorParameter->typesFromSignature);
+		if (property_exists($separatorParameter->defaultValue, 'value')) {
+			self::assertEquals('', $separatorParameter->defaultValue->value);
+		} else {
+			self::fail("Couldn't read default value");
+		}
+		self::assertEquals(['?array'], $arrayParameter->typesFromSignature);
+		self::assertEquals(['string'], $implodeFunction->returnTypesFromSignature);
+		self::assertEquals(['string'], $implodeFunction->returnTypesFromPhpDoc);
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -61,8 +61,8 @@ 
             $function->parameters,
             $uniqueParameterNames,
             "Parameter number mismatch for function $functionName. 
-                Expected: " . BaseStubsTest::getParameterRepresentation($function) . "\n" .
-            'Actual: ' . BaseStubsTest::getParameterRepresentation($stubFunction)
+                Expected: ".BaseStubsTest::getParameterRepresentation($function)."\n".
+            'Actual: '.BaseStubsTest::getParameterRepresentation($stubFunction)
         );
     }
 
@@ -79,7 +79,7 @@ 
         self::assertCount(
             0,
             $duplicates,
-            "Functions \"" . implode(', ', $duplicates) .
+            "Functions \"".implode(', ', $duplicates).
             "\" have duplicates in stubs.\nPlease use #[LanguageLevelTypeAware] or #[PhpStormStubsElementAvailable] if possible"
         );
     }
@@ -115,7 +115,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersProvider
      * @throws RuntimeException
      */
-    public function testMethodsOptionalParameters(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
+    public function testMethodsOptionalParameters(PHPClass | PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
     {
         if ($class instanceof PHPClass) {
             $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);

Braces +1 added lines, -2 removed lines

@@ -15,8 +15,7 @@
 use StubTests\TestData\Providers\EntitiesFilter;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class BaseFunctionsTest extends BaseStubsTest
-{
+class BaseFunctionsTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
      * @throws Exception|RuntimeException

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

Indentation +298 added lines, -298 removed lines

@@ -17,333 +17,333 @@
 
 class StubsTypeHintsTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
-     * @throws RuntimeException
-     */
-    public function testFunctionsReturnTypeHints(PHPFunction $function)
-    {
-        $functionName = $function->name;
-        $stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
-        $unifiedStubsReturnTypes = [];
-        $unifiedStubsAttributesReturnTypes = [];
-        $unifiedReflectionReturnTypes = [];
-        self::convertNullableTypesToUnion($function->returnTypesFromSignature, $unifiedReflectionReturnTypes);
-        if (!empty($stubFunction->returnTypesFromSignature)) {
-            self::convertNullableTypesToUnion($stubFunction->returnTypesFromSignature, $unifiedStubsReturnTypes);
-        }
-        foreach ($stubFunction->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, "Function $functionName has invalid return type.
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
+	 * @throws RuntimeException
+	 */
+	public function testFunctionsReturnTypeHints(PHPFunction $function)
+	{
+		$functionName = $function->name;
+		$stubFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
+		$unifiedStubsReturnTypes = [];
+		$unifiedStubsAttributesReturnTypes = [];
+		$unifiedReflectionReturnTypes = [];
+		self::convertNullableTypesToUnion($function->returnTypesFromSignature, $unifiedReflectionReturnTypes);
+		if (!empty($stubFunction->returnTypesFromSignature)) {
+			self::convertNullableTypesToUnion($stubFunction->returnTypesFromSignature, $unifiedStubsReturnTypes);
+		}
+		foreach ($stubFunction->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, "Function $functionName has invalid return type.
         Reflection function has return type " . implode('|', $function->returnTypesFromSignature) . ' but stubs has return type ' .
-            implode('|', $stubFunction->returnTypesFromSignature) . ' in signature and attribute has types ' .
-            implode('|', $typesFromAttribute));
-    }
+			implode('|', $stubFunction->returnTypesFromSignature) . ' in signature and attribute has types ' .
+			implode('|', $typesFromAttribute));
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionParametersWithTypeProvider
-     * @throws RuntimeException
-     */
-    public function testFunctionsParametersTypeHints(PHPFunction $function, PHPParameter $parameter)
-    {
-        $functionName = $function->name;
-        $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
-        /** @var PHPParameter $stubParameter */
-        $stubParameter = current(array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature));
-        self::compareTypeHintsWithReflection($parameter, $stubParameter, $functionName);
-        if (!$parameter->hasMutedProblem(StubProblemType::PARAMETER_REFERENCE)) {
-            self::assertEquals(
-                $parameter->is_passed_by_ref,
-                $stubParameter->is_passed_by_ref,
-                "Invalid pass by ref $functionName: \$$parameter->name "
-            );
-        }
-        self::assertEquals(
-            $parameter->is_vararg,
-            $stubParameter->is_vararg,
-            "Invalid vararg $functionName: \$$parameter->name "
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionParametersWithTypeProvider
+	 * @throws RuntimeException
+	 */
+	public function testFunctionsParametersTypeHints(PHPFunction $function, PHPParameter $parameter)
+	{
+		$functionName = $function->name;
+		$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($functionName);
+		/** @var PHPParameter $stubParameter */
+		$stubParameter = current(array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature));
+		self::compareTypeHintsWithReflection($parameter, $stubParameter, $functionName);
+		if (!$parameter->hasMutedProblem(StubProblemType::PARAMETER_REFERENCE)) {
+			self::assertEquals(
+				$parameter->is_passed_by_ref,
+				$stubParameter->is_passed_by_ref,
+				"Invalid pass by ref $functionName: \$$parameter->name "
+			);
+		}
+		self::assertEquals(
+			$parameter->is_vararg,
+			$stubParameter->is_vararg,
+			"Invalid vararg $functionName: \$$parameter->name "
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithoutTentitiveReturnTypeProvider
-     * @throws RuntimeException
-     */
-    public function testMethodsReturnTypeHints(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.
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithoutTentitiveReturnTypeProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodsReturnTypeHints(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));
-    }
+			implode('|', $stubMethod->returnTypesFromSignature) . ' in signature and attribute has types ' .
+			implode('|', $typesFromAttribute));
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodParametersProvider
-     * @throws RuntimeException
-     */
-    public function testMethodsParametersTypeHints(PHPClass|PHPInterface $reflectionClass, PHPMethod $reflectionMethod, PHPParameter $reflectionParameter)
-    {
-        $className = $reflectionClass->name;
-        $methodName = $reflectionMethod->name;
-        if ($reflectionClass instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($methodName);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($methodName);
-        }
-        /** @var PHPParameter $stubParameter */
-        $stubParameter = current(array_filter(
-            $stubMethod->parameters,
-            fn (PHPParameter $stubParameter) => $stubParameter->name === $reflectionParameter->name
-        ));
-        self::assertNotFalse($stubParameter, "Parameter $$reflectionParameter->name not found at 
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodParametersProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodsParametersTypeHints(PHPClass|PHPInterface $reflectionClass, PHPMethod $reflectionMethod, PHPParameter $reflectionParameter)
+	{
+		$className = $reflectionClass->name;
+		$methodName = $reflectionMethod->name;
+		if ($reflectionClass instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($methodName);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($methodName);
+		}
+		/** @var PHPParameter $stubParameter */
+		$stubParameter = current(array_filter(
+			$stubMethod->parameters,
+			fn (PHPParameter $stubParameter) => $stubParameter->name === $reflectionParameter->name
+		));
+		self::assertNotFalse($stubParameter, "Parameter $$reflectionParameter->name not found at 
         $reflectionClass->name::$stubMethod->name(" .
-            StubsParameterNamesTest::printParameters($stubMethod->parameters) . ')');
-        self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $methodName);
-        if (!$reflectionParameter->hasMutedProblem(StubProblemType::PARAMETER_REFERENCE)) {
-            self::assertEquals(
-                $reflectionParameter->is_passed_by_ref,
-                $stubParameter->is_passed_by_ref,
-                "Invalid pass by ref $className::$methodName: \$$reflectionParameter->name "
-            );
-        }
-        self::assertEquals(
-            $reflectionParameter->is_vararg,
-            $stubParameter->is_vararg,
-            "Invalid pass by ref $className::$methodName: \$$reflectionParameter->name "
-        );
-    }
+			StubsParameterNamesTest::printParameters($stubMethod->parameters) . ')');
+		self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $methodName);
+		if (!$reflectionParameter->hasMutedProblem(StubProblemType::PARAMETER_REFERENCE)) {
+			self::assertEquals(
+				$reflectionParameter->is_passed_by_ref,
+				$stubParameter->is_passed_by_ref,
+				"Invalid pass by ref $className::$methodName: \$$reflectionParameter->name "
+			);
+		}
+		self::assertEquals(
+			$reflectionParameter->is_vararg,
+			$stubParameter->is_vararg,
+			"Invalid pass by ref $className::$methodName: \$$reflectionParameter->name "
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForScalarTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveScalarTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        self::assertEmpty(
-            array_intersect(['int', 'float', 'string', 'bool', 'mixed', 'object'], $parameter->typesFromSignature),
-            "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForScalarTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveScalarTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		self::assertEmpty(
+			array_intersect(['int', 'float', 'string', 'bool', 'mixed', 'object'], $parameter->typesFromSignature),
+			"Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
                 has parameter '$parameter->name' with typehint '" . implode('|', $parameter->typesFromSignature) .
-            "' but typehints available only since php 7"
-        );
-    }
+			"' but typehints available only since php 7"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForNullableTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveNullableTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        self::assertEmpty(
-            array_filter($parameter->typesFromSignature, fn (string $type) => str_contains($type, '?')),
-            "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForNullableTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveNullableTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		self::assertEmpty(
+			array_filter($parameter->typesFromSignature, fn (string $type) => str_contains($type, '?')),
+			"Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
                 has nullable parameter '$parameter->name' with typehint '" . implode('|', $parameter->typesFromSignature) . "' 
                 but nullable typehints available only since php 7.1"
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForUnionTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveUnionTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        self::assertLessThan(
-            2,
-            count($parameter->typesFromSignature),
-            "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForUnionTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveUnionTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		self::assertLessThan(
+			2,
+			count($parameter->typesFromSignature),
+			"Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
                 has parameter '$parameter->name' with union typehint '" . implode('|', $parameter->typesFromSignature) . "' 
                 but union typehints available only since php 8.0"
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForReturnTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveReturnTypeHint(PHPMethod $stubMethod)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        self::assertEmpty($stubMethod->returnTypesFromSignature, "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForReturnTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveReturnTypeHint(PHPMethod $stubMethod)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		self::assertEmpty($stubMethod->returnTypesFromSignature, "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
             but has return typehint '" . implode('|', $stubMethod->returnTypesFromSignature) . "' that supported only since PHP 7. Please declare return type via PhpDoc");
-    }
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForNullableReturnTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveNullableReturnTypeHint(PHPMethod $stubMethod)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        $returnTypes = $stubMethod->returnTypesFromSignature;
-        self::assertEmpty(
-            array_filter($returnTypes, fn (string $type) => str_contains($type, '?')),
-            "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForNullableReturnTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveNullableReturnTypeHint(PHPMethod $stubMethod)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		$returnTypes = $stubMethod->returnTypesFromSignature;
+		self::assertEmpty(
+			array_filter($returnTypes, fn (string $type) => str_contains($type, '?')),
+			"Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
             but has nullable return typehint '" . implode('|', $returnTypes) . "' that supported only since PHP 7.1. 
             Please declare return type via PhpDoc"
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForUnionReturnTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public static function testMethodDoesNotHaveUnionReturnTypeHint(PHPMethod $stubMethod)
-    {
-        $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
-        self::assertLessThan(
-            2,
-            count($stubMethod->returnTypesFromSignature),
-            "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::methodsForUnionReturnTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public static function testMethodDoesNotHaveUnionReturnTypeHint(PHPMethod $stubMethod)
+	{
+		$sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
+		self::assertLessThan(
+			2,
+			count($stubMethod->returnTypesFromSignature),
+			"Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
             but has union return typehint '" . implode('|', $stubMethod->returnTypesFromSignature) . "' that supported only since PHP 8.0. 
             Please declare return type via PhpDoc"
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedScalarTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public function testMethodScalarTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
-    {
-        $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
-        $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
-        $reflectionParameter = array_pop($reflectionParameters);
-        self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedScalarTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodScalarTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+	{
+		$reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
+		$reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
+		$reflectionParameter = array_pop($reflectionParameters);
+		self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedNullableTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public function testMethodNullableTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
-    {
-        $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
-        $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
-        $reflectionParameter = array_pop($reflectionParameters);
-        self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedNullableTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodNullableTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+	{
+		$reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
+		$reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
+		$reflectionParameter = array_pop($reflectionParameters);
+		self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedUnionTypeHintTestsProvider
-     * @throws RuntimeException
-     */
-    public function testMethodUnionTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
-    {
-        $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
-        $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
-        $reflectionParameter = array_pop($reflectionParameters);
-        self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedUnionTypeHintTestsProvider
+	 * @throws RuntimeException
+	 */
+	public function testMethodUnionTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+	{
+		$reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
+		$reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
+		$reflectionParameter = array_pop($reflectionParameters);
+		self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $stubMethod->name);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::allFunctionAndMethodsWithReturnTypeHintsProvider
-     * @throws Exception
-     */
-    public static function testSignatureTypeHintsComplainPhpDocInMethods(PHPFunction|PHPMethod $method)
-    {
-        $functionName = $method->name;
-        $unifiedPhpDocTypes = array_map(function (string $type) {
-            $typeParts = explode('\\', $type);
-            $typeName = end($typeParts);
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::allFunctionAndMethodsWithReturnTypeHintsProvider
+	 * @throws Exception
+	 */
+	public static function testSignatureTypeHintsComplainPhpDocInMethods(PHPFunction|PHPMethod $method)
+	{
+		$functionName = $method->name;
+		$unifiedPhpDocTypes = array_map(function (string $type) {
+			$typeParts = explode('\\', $type);
+			$typeName = end($typeParts);
 
-            // replace array notations like int[] or array<string,mixed> to match the array type
-            return preg_replace(['/\w+\[]/', '/array<[a-z,\s]+>/'], 'array', $typeName);
-        }, $method->returnTypesFromPhpDoc);
-        $unifiedSignatureTypes = $method->returnTypesFromSignature;
-        if (count($unifiedSignatureTypes) === 1) {
-            $unifiedSignatureTypes = [];
-            $type = array_pop($method->returnTypesFromSignature);
-            if (str_contains($type, '?')) {
-                array_push($unifiedSignatureTypes, 'null');
-            }
-            $typeParts = explode('\\', ltrim($type, '?'));
-            $typeName = end($typeParts);
-            array_push($unifiedSignatureTypes, $typeName);
-        }
-        $typesIntersection = array_intersect($unifiedSignatureTypes, $unifiedPhpDocTypes);
-        self::assertSameSize(
-            $unifiedSignatureTypes,
-            $typesIntersection,
-            $method instanceof PHPMethod ? "Method $method->parentName::" : 'Function ' .
-                "$functionName has mismatch in phpdoc return type and signature return type\n
+			// replace array notations like int[] or array<string,mixed> to match the array type
+			return preg_replace(['/\w+\[]/', '/array<[a-z,\s]+>/'], 'array', $typeName);
+		}, $method->returnTypesFromPhpDoc);
+		$unifiedSignatureTypes = $method->returnTypesFromSignature;
+		if (count($unifiedSignatureTypes) === 1) {
+			$unifiedSignatureTypes = [];
+			$type = array_pop($method->returnTypesFromSignature);
+			if (str_contains($type, '?')) {
+				array_push($unifiedSignatureTypes, 'null');
+			}
+			$typeParts = explode('\\', ltrim($type, '?'));
+			$typeName = end($typeParts);
+			array_push($unifiedSignatureTypes, $typeName);
+		}
+		$typesIntersection = array_intersect($unifiedSignatureTypes, $unifiedPhpDocTypes);
+		self::assertSameSize(
+			$unifiedSignatureTypes,
+			$typesIntersection,
+			$method instanceof PHPMethod ? "Method $method->parentName::" : 'Function ' .
+				"$functionName has mismatch in phpdoc return type and signature return type\n
                 signature has " . implode('|', $unifiedSignatureTypes) . "\n
                 but phpdoc has " . implode('|', $unifiedPhpDocTypes)
-        );
-    }
+		);
+	}
 
-    private static function compareTypeHintsWithReflection(PHPParameter $parameter, PHPParameter $stubParameter, ?string $functionName): void
-    {
-        $unifiedStubsParameterTypes = [];
-        $unifiedStubsAttributesParameterTypes = [];
-        $unifiedReflectionParameterTypes = [];
-        self::convertNullableTypesToUnion($parameter->typesFromSignature, $unifiedReflectionParameterTypes);
-        if (!empty($stubParameter->typesFromSignature)) {
-            self::convertNullableTypesToUnion($stubParameter->typesFromSignature, $unifiedStubsParameterTypes);
-        }
-        foreach ($stubParameter->typesFromAttribute as $languageVersion => $listOfTypes) {
-            $unifiedStubsAttributesParameterTypes[$languageVersion] = [];
-            self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesParameterTypes[$languageVersion]);
-        }
-        $typesFromAttribute = [];
-        $testCondition = BaseStubsTest::isReflectionTypesMatchSignature($unifiedReflectionParameterTypes, $unifiedStubsParameterTypes);
-        if (!$testCondition) {
-            if (!empty($unifiedStubsAttributesParameterTypes)) {
-                $typesFromAttribute = !empty($unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')]) ?
-                    $unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')] :
-                    $unifiedStubsAttributesParameterTypes['default'];
-                $testCondition = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionParameterTypes, $typesFromAttribute);
-            }
-        }
-        self::assertTrue($testCondition, "Type mismatch $functionName: \$$parameter->name \n
+	private static function compareTypeHintsWithReflection(PHPParameter $parameter, PHPParameter $stubParameter, ?string $functionName): void
+	{
+		$unifiedStubsParameterTypes = [];
+		$unifiedStubsAttributesParameterTypes = [];
+		$unifiedReflectionParameterTypes = [];
+		self::convertNullableTypesToUnion($parameter->typesFromSignature, $unifiedReflectionParameterTypes);
+		if (!empty($stubParameter->typesFromSignature)) {
+			self::convertNullableTypesToUnion($stubParameter->typesFromSignature, $unifiedStubsParameterTypes);
+		}
+		foreach ($stubParameter->typesFromAttribute as $languageVersion => $listOfTypes) {
+			$unifiedStubsAttributesParameterTypes[$languageVersion] = [];
+			self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesParameterTypes[$languageVersion]);
+		}
+		$typesFromAttribute = [];
+		$testCondition = BaseStubsTest::isReflectionTypesMatchSignature($unifiedReflectionParameterTypes, $unifiedStubsParameterTypes);
+		if (!$testCondition) {
+			if (!empty($unifiedStubsAttributesParameterTypes)) {
+				$typesFromAttribute = !empty($unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')]) ?
+					$unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')] :
+					$unifiedStubsAttributesParameterTypes['default'];
+				$testCondition = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionParameterTypes, $typesFromAttribute);
+			}
+		}
+		self::assertTrue($testCondition, "Type mismatch $functionName: \$$parameter->name \n
         Reflection parameter $parameter->name with index $parameter->indexInSignature has type '" . implode('|', $unifiedReflectionParameterTypes) .
-            "' but stub parameter $stubParameter->name with index $stubParameter->indexInSignature has type '" . implode('|', $unifiedStubsParameterTypes) . "' in signature and " .
-            implode('|', $typesFromAttribute) . ' in attribute');
-    }
+			"' but stub parameter $stubParameter->name with index $stubParameter->indexInSignature has type '" . implode('|', $unifiedStubsParameterTypes) . "' in signature and " .
+			implode('|', $typesFromAttribute) . ' in attribute');
+	}
 }

Spacing +30 added lines, -33 removed lines

@@ -43,14 +43,13 @@ 
         $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, "Function $functionName has invalid return type.
-        Reflection function has return type " . implode('|', $function->returnTypesFromSignature) . ' but stubs has return type ' .
-            implode('|', $stubFunction->returnTypesFromSignature) . ' in signature and attribute has types ' .
+        Reflection function has return type ".implode('|', $function->returnTypesFromSignature).' but stubs has return type '.
+            implode('|', $stubFunction->returnTypesFromSignature).' in signature and attribute has types '.
             implode('|', $typesFromAttribute));
     }
 
@@ -83,7 +82,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithoutTentitiveReturnTypeProvider
      * @throws RuntimeException
      */
-    public function testMethodsReturnTypeHints(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testMethodsReturnTypeHints(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $functionName = $method->name;
         if ($class instanceof PHPClass) {
@@ -110,14 +109,13 @@ 
         $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 ' .
+        Reflection method has return type ".implode('|', $method->returnTypesFromSignature).' but stubs has return type '.
+            implode('|', $stubMethod->returnTypesFromSignature).' in signature and attribute has types '.
             implode('|', $typesFromAttribute));
     }
 
@@ -125,7 +123,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodParametersProvider
      * @throws RuntimeException
      */
-    public function testMethodsParametersTypeHints(PHPClass|PHPInterface $reflectionClass, PHPMethod $reflectionMethod, PHPParameter $reflectionParameter)
+    public function testMethodsParametersTypeHints(PHPClass | PHPInterface $reflectionClass, PHPMethod $reflectionMethod, PHPParameter $reflectionParameter)
     {
         $className = $reflectionClass->name;
         $methodName = $reflectionMethod->name;
@@ -140,8 +138,8 @@ 
             fn (PHPParameter $stubParameter) => $stubParameter->name === $reflectionParameter->name
         ));
         self::assertNotFalse($stubParameter, "Parameter $$reflectionParameter->name not found at 
-        $reflectionClass->name::$stubMethod->name(" .
-            StubsParameterNamesTest::printParameters($stubMethod->parameters) . ')');
+        $reflectionClass->name::$stubMethod->name(".
+            StubsParameterNamesTest::printParameters($stubMethod->parameters).')');
         self::compareTypeHintsWithReflection($reflectionParameter, $stubParameter, $methodName);
         if (!$reflectionParameter->hasMutedProblem(StubProblemType::PARAMETER_REFERENCE)) {
             self::assertEquals(
@@ -161,13 +159,13 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForScalarTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public static function testMethodDoesNotHaveScalarTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+    public static function testMethodDoesNotHaveScalarTypeHintsInParameters(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
     {
         $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
         self::assertEmpty(
             array_intersect(['int', 'float', 'string', 'bool', 'mixed', 'object'], $parameter->typesFromSignature),
             "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
-                has parameter '$parameter->name' with typehint '" . implode('|', $parameter->typesFromSignature) .
+                has parameter '$parameter->name' with typehint '".implode('|', $parameter->typesFromSignature).
             "' but typehints available only since php 7"
         );
     }
@@ -176,13 +174,13 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForNullableTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public static function testMethodDoesNotHaveNullableTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+    public static function testMethodDoesNotHaveNullableTypeHintsInParameters(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
     {
         $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
         self::assertEmpty(
             array_filter($parameter->typesFromSignature, fn (string $type) => str_contains($type, '?')),
             "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
-                has nullable parameter '$parameter->name' with typehint '" . implode('|', $parameter->typesFromSignature) . "' 
+                has nullable parameter '$parameter->name' with typehint '".implode('|', $parameter->typesFromSignature)."' 
                 but nullable typehints available only since php 7.1"
         );
     }
@@ -191,14 +189,14 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForUnionTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public static function testMethodDoesNotHaveUnionTypeHintsInParameters(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
+    public static function testMethodDoesNotHaveUnionTypeHintsInParameters(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $parameter)
     {
         $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
         self::assertLessThan(
             2,
             count($parameter->typesFromSignature),
             "Method '$class->name::$stubMethod->name' with @since '$sinceVersion'  
-                has parameter '$parameter->name' with union typehint '" . implode('|', $parameter->typesFromSignature) . "' 
+                has parameter '$parameter->name' with union typehint '".implode('|', $parameter->typesFromSignature)."' 
                 but union typehints available only since php 8.0"
         );
     }
@@ -211,7 +209,7 @@ 
     {
         $sinceVersion = ParserUtils::getDeclaredSinceVersion($stubMethod);
         self::assertEmpty($stubMethod->returnTypesFromSignature, "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
-            but has return typehint '" . implode('|', $stubMethod->returnTypesFromSignature) . "' that supported only since PHP 7. Please declare return type via PhpDoc");
+            but has return typehint '".implode('|', $stubMethod->returnTypesFromSignature)."' that supported only since PHP 7. Please declare return type via PhpDoc");
     }
 
     /**
@@ -225,7 +223,7 @@ 
         self::assertEmpty(
             array_filter($returnTypes, fn (string $type) => str_contains($type, '?')),
             "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
-            but has nullable return typehint '" . implode('|', $returnTypes) . "' that supported only since PHP 7.1. 
+            but has nullable return typehint '".implode('|', $returnTypes)."' that supported only since PHP 7.1. 
             Please declare return type via PhpDoc"
         );
     }
@@ -241,7 +239,7 @@ 
             2,
             count($stubMethod->returnTypesFromSignature),
             "Method '$stubMethod->parentName::$stubMethod->name' has since version '$sinceVersion'
-            but has union return typehint '" . implode('|', $stubMethod->returnTypesFromSignature) . "' that supported only since PHP 8.0. 
+            but has union return typehint '".implode('|', $stubMethod->returnTypesFromSignature)."' that supported only since PHP 8.0. 
             Please declare return type via PhpDoc"
         );
     }
@@ -250,7 +248,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedScalarTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public function testMethodScalarTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+    public function testMethodScalarTypeHintsInParametersMatchReflection(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
     {
         $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
         $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
@@ -262,7 +260,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedNullableTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public function testMethodNullableTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+    public function testMethodNullableTypeHintsInParametersMatchReflection(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
     {
         $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
         $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
@@ -274,7 +272,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubsParametersProvider::parametersForAllowedUnionTypeHintTestsProvider
      * @throws RuntimeException
      */
-    public function testMethodUnionTypeHintsInParametersMatchReflection(PHPClass|PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
+    public function testMethodUnionTypeHintsInParametersMatchReflection(PHPClass | PHPInterface $class, PHPMethod $stubMethod, PHPParameter $stubParameter)
     {
         $reflectionMethod = ReflectionStubsSingleton::getReflectionStubs()->getClass($class->name)->getMethod($stubMethod->name);
         $reflectionParameters = array_filter($reflectionMethod->parameters, fn (PHPParameter $parameter) => $parameter->name === $stubParameter->name);
@@ -286,10 +284,10 @@ 
      * @dataProvider \StubTests\TestData\Providers\Stubs\StubMethodsProvider::allFunctionAndMethodsWithReturnTypeHintsProvider
      * @throws Exception
      */
-    public static function testSignatureTypeHintsComplainPhpDocInMethods(PHPFunction|PHPMethod $method)
+    public static function testSignatureTypeHintsComplainPhpDocInMethods(PHPFunction | PHPMethod $method)
     {
         $functionName = $method->name;
-        $unifiedPhpDocTypes = array_map(function (string $type) {
+        $unifiedPhpDocTypes = array_map(function(string $type) {
             $typeParts = explode('\\', $type);
             $typeName = end($typeParts);
 
@@ -311,9 +309,9 @@ 
         self::assertSameSize(
             $unifiedSignatureTypes,
             $typesIntersection,
-            $method instanceof PHPMethod ? "Method $method->parentName::" : 'Function ' .
+            $method instanceof PHPMethod ? "Method $method->parentName::" : 'Function '.
                 "$functionName has mismatch in phpdoc return type and signature return type\n
-                signature has " . implode('|', $unifiedSignatureTypes) . "\n
+                signature has ".implode('|', $unifiedSignatureTypes)."\n
                 but phpdoc has " . implode('|', $unifiedPhpDocTypes)
         );
     }
@@ -336,14 +334,13 @@ 
         if (!$testCondition) {
             if (!empty($unifiedStubsAttributesParameterTypes)) {
                 $typesFromAttribute = !empty($unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')]) ?
-                    $unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')] :
-                    $unifiedStubsAttributesParameterTypes['default'];
+                    $unifiedStubsAttributesParameterTypes[getenv('PHP_VERSION')] : $unifiedStubsAttributesParameterTypes['default'];
                 $testCondition = BaseStubsTest::isReflectionTypesExistInAttributes($unifiedReflectionParameterTypes, $typesFromAttribute);
             }
         }
         self::assertTrue($testCondition, "Type mismatch $functionName: \$$parameter->name \n
-        Reflection parameter $parameter->name with index $parameter->indexInSignature has type '" . implode('|', $unifiedReflectionParameterTypes) .
-            "' but stub parameter $stubParameter->name with index $stubParameter->indexInSignature has type '" . implode('|', $unifiedStubsParameterTypes) . "' in signature and " .
-            implode('|', $typesFromAttribute) . ' in attribute');
+        Reflection parameter $parameter->name with index $parameter->indexInSignature has type '".implode('|', $unifiedReflectionParameterTypes).
+            "' but stub parameter $stubParameter->name with index $stubParameter->indexInSignature has type '".implode('|', $unifiedStubsParameterTypes)."' in signature and ".
+            implode('|', $typesFromAttribute).' in attribute');
     }
 }

Braces +1 added lines, -2 removed lines

@@ -15,8 +15,7 @@
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 use StubTests\TestData\Providers\ReflectionStubsSingleton;
 
-class StubsTypeHintsTest extends BaseStubsTest
-{
+class StubsTypeHintsTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionFunctionsProvider::allFunctionsProvider
      * @throws RuntimeException

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

Indentation +51 added lines, -51 removed lines

@@ -12,58 +12,58 @@
 
 class BaseConstantsTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantProvider
-     * @throws Exception
-     */
-    public function testConstants(PHPConst $constant): void
-    {
-        $constantName = $constant->name;
-        $constantValue = $constant->value;
-        $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getConstant($constantName);
-        static::assertNotEmpty(
-            $stubConstant,
-            "Missing constant: const $constantName = $constantValue\n"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantProvider
+	 * @throws Exception
+	 */
+	public function testConstants(PHPConst $constant): void
+	{
+		$constantName = $constant->name;
+		$constantValue = $constant->value;
+		$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getConstant($constantName);
+		static::assertNotEmpty(
+			$stubConstant,
+			"Missing constant: const $constantName = $constantValue\n"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassConstants(PHPClass|PHPInterface $class, PHPConst $constant): void
-    {
-        $constantName = $constant->name;
-        $constantValue = $constant->value;
-        if ($class instanceof PHPClass) {
-            $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getConstant($constantName);
-        } else {
-            $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getConstant($constantName);
-        }
-        static::assertNotEmpty(
-            $stubConstant,
-            "Missing constant: const $constantName = $constantValue\n"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassConstants(PHPClass|PHPInterface $class, PHPConst $constant): void
+	{
+		$constantName = $constant->name;
+		$constantValue = $constant->value;
+		if ($class instanceof PHPClass) {
+			$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getConstant($constantName);
+		} else {
+			$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getConstant($constantName);
+		}
+		static::assertNotEmpty(
+			$stubConstant,
+			"Missing constant: const $constantName = $constantValue\n"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
-     * @throws RuntimeException
-     */
-    public function testClassConstantsVisibility(PHPClass|PHPInterface $class, PHPConst $constant): void
-    {
-        $constantName = $constant->name;
-        $constantVisibility = $constant->visibility;
-        if ($class instanceof PHPClass) {
-            $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getConstant($constantName);
-        } else {
-            $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getConstant($constantName);
-        }
-        static::assertEquals(
-            $constantVisibility,
-            $stubConstant->visibility,
-            "Constant visibility mismatch: const $constantName \n
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassConstantsVisibility(PHPClass|PHPInterface $class, PHPConst $constant): void
+	{
+		$constantName = $constant->name;
+		$constantVisibility = $constant->visibility;
+		if ($class instanceof PHPClass) {
+			$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getConstant($constantName);
+		} else {
+			$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getConstant($constantName);
+		}
+		static::assertEquals(
+			$constantVisibility,
+			$stubConstant->visibility,
+			"Constant visibility mismatch: const $constantName \n
             Expected visibility: $constantVisibility but was $stubConstant->visibility"
-        );
-    }
+		);
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -31,7 +31,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
      * @throws Exception|RuntimeException
      */
-    public function testClassConstants(PHPClass|PHPInterface $class, PHPConst $constant): void
+    public function testClassConstants(PHPClass | PHPInterface $class, PHPConst $constant): void
     {
         $constantName = $constant->name;
         $constantValue = $constant->value;
@@ -50,7 +50,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::classConstantProvider
      * @throws RuntimeException
      */
-    public function testClassConstantsVisibility(PHPClass|PHPInterface $class, PHPConst $constant): void
+    public function testClassConstantsVisibility(PHPClass | PHPInterface $class, PHPConst $constant): void
     {
         $constantName = $constant->name;
         $constantVisibility = $constant->visibility;

Braces +1 added lines, -2 removed lines

@@ -10,8 +10,7 @@
 use StubTests\Model\PHPInterface;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class BaseConstantsTest extends BaseStubsTest
-{
+class BaseConstantsTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantProvider
      * @throws Exception

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Tools/dump-pecl-to-file.php

Indentation +12 added lines, -12 removed lines

@@ -11,23 +11,23 @@
 $peclAndCoreStubs = unserialize(file_get_contents(__DIR__ . '/../../ReflectionDataPecl.json'), ['allowed_classes' => true]);
 $onlyPeclStubs = new StubsContainer();
 foreach ($peclAndCoreStubs->getConstants() as $peclConstant) {
-    if (empty(array_filter($coreStubs->getConstants(), fn ($constant) => $constant->name === $peclConstant->name))) {
-        $onlyPeclStubs->addConstant($peclConstant);
-    }
+	if (empty(array_filter($coreStubs->getConstants(), fn ($constant) => $constant->name === $peclConstant->name))) {
+		$onlyPeclStubs->addConstant($peclConstant);
+	}
 }
 foreach ($peclAndCoreStubs->getClasses() as $peclClass) {
-    if (empty(array_filter($coreStubs->getClasses(), fn ($class) => $class->name === $peclClass->name))) {
-        $onlyPeclStubs->addClass($peclClass);
-    }
+	if (empty(array_filter($coreStubs->getClasses(), fn ($class) => $class->name === $peclClass->name))) {
+		$onlyPeclStubs->addClass($peclClass);
+	}
 }
 foreach ($peclAndCoreStubs->getFunctions() as $peclFunction) {
-    if (empty(array_filter($coreStubs->getFunctions(), fn ($function) => $function->name === $peclFunction->name))) {
-        $onlyPeclStubs->addFunction($peclFunction);
-    }
+	if (empty(array_filter($coreStubs->getFunctions(), fn ($function) => $function->name === $peclFunction->name))) {
+		$onlyPeclStubs->addFunction($peclFunction);
+	}
 }
 foreach ($peclAndCoreStubs->getInterfaces() as $peclInterface) {
-    if (empty(array_filter($coreStubs->getInterfaces(), fn ($interface) => $interface->name === $peclInterface->name))) {
-        $onlyPeclStubs->addInterface($peclInterface);
-    }
+	if (empty(array_filter($coreStubs->getInterfaces(), fn ($interface) => $interface->name === $peclInterface->name))) {
+		$onlyPeclStubs->addInterface($peclInterface);
+	}
 }
 file_put_contents(__DIR__ . '/../../ReflectionData.json', serialize($onlyPeclStubs));

Spacing +4 added lines, -4 removed lines

@@ -3,12 +3,12 @@ 
 
 use StubTests\Model\StubsContainer;
 
-require_once __DIR__ . '/../../vendor/autoload.php';
+require_once __DIR__.'/../../vendor/autoload.php';
 
 /** @var StubsContainer $coreStubs */
-$coreStubs = unserialize(file_get_contents(__DIR__ . '/../../ReflectionData.json'), ['allowed_classes' => true]);
+$coreStubs = unserialize(file_get_contents(__DIR__.'/../../ReflectionData.json'), ['allowed_classes' => true]);
 /** @var StubsContainer $peclAndCoreStubs */
-$peclAndCoreStubs = unserialize(file_get_contents(__DIR__ . '/../../ReflectionDataPecl.json'), ['allowed_classes' => true]);
+$peclAndCoreStubs = unserialize(file_get_contents(__DIR__.'/../../ReflectionDataPecl.json'), ['allowed_classes' => true]);
 $onlyPeclStubs = new StubsContainer();
 foreach ($peclAndCoreStubs->getConstants() as $peclConstant) {
     if (empty(array_filter($coreStubs->getConstants(), fn ($constant) => $constant->name === $peclConstant->name))) {
@@ -30,4 +30,4 @@ 
         $onlyPeclStubs->addInterface($peclInterface);
     }
 }
-file_put_contents(__DIR__ . '/../../ReflectionData.json', serialize($onlyPeclStubs));
+file_put_contents(__DIR__.'/../../ReflectionData.json', serialize($onlyPeclStubs));

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/Tools/dump-reflection-to-file.php

Spacing +2 added lines, -2 removed lines

@@ -3,9 +3,9 @@
 
 namespace StubTests\TestData;
 
-require_once __DIR__ . '/../../vendor/autoload.php';
+require_once __DIR__.'/../../vendor/autoload.php';
 
 use StubTests\TestData\Providers\ReflectionStubsSingleton;
 
 $reflectionFileName = $argv[1];
-file_put_contents(__DIR__ . "/../../$reflectionFileName", serialize(ReflectionStubsSingleton::getReflectionStubs()));
+file_put_contents(__DIR__."/../../$reflectionFileName", serialize(ReflectionStubsSingleton::getReflectionStubs()));

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

Indentation +67 added lines, -67 removed lines

@@ -15,74 +15,74 @@
 
 class StubsConstantsAndParametersValuesTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantValuesProvider
-     */
-    public function testConstantsValues(PHPConst $constant): void
-    {
-        $constantName = $constant->name;
-        $constantValue = $constant->value;
-        $stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getConstant($constantName);
-        self::assertEquals(
-            $constantValue,
-            $stubConstant->value,
-            "Constant value mismatch: const $constantName \n
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantValuesProvider
+	 */
+	public function testConstantsValues(PHPConst $constant): void
+	{
+		$constantName = $constant->name;
+		$constantValue = $constant->value;
+		$stubConstant = PhpStormStubsSingleton::getPhpStormStubs()->getConstant($constantName);
+		self::assertEquals(
+			$constantValue,
+			$stubConstant->value,
+			"Constant value mismatch: const $constantName \n
             Expected value: $constantValue but was $stubConstant->value"
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionOptionalParametersWithDefaultValueProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testFunctionsDefaultParametersValue(PHPFunction $function, PHPParameter $parameter)
-    {
-        $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($function->name);
-        $stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
-        /** @var PHPParameter $stubOptionalParameter */
-        $stubOptionalParameter = array_pop($stubParameters);
-        $reflectionValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($parameter->defaultValue);
-        $stubValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($stubOptionalParameter->defaultValue);
-        self::assertEquals(
-            $reflectionValue,
-            $stubValue,
-            sprintf(
-                'Reflection function %s has optional parameter %s with default value %s but stub parameter has value %s',
-                $function->name,
-                $parameter->name,
-                $reflectionValue,
-                $stubValue
-            )
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::functionOptionalParametersWithDefaultValueProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testFunctionsDefaultParametersValue(PHPFunction $function, PHPParameter $parameter)
+	{
+		$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getFunction($function->name);
+		$stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
+		/** @var PHPParameter $stubOptionalParameter */
+		$stubOptionalParameter = array_pop($stubParameters);
+		$reflectionValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($parameter->defaultValue);
+		$stubValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($stubOptionalParameter->defaultValue);
+		self::assertEquals(
+			$reflectionValue,
+			$stubValue,
+			sprintf(
+				'Reflection function %s has optional parameter %s with default value %s but stub parameter has value %s',
+				$function->name,
+				$parameter->name,
+				$reflectionValue,
+				$stubValue
+			)
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersWithDefaultValueProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testMethodsDefaultParametersValue(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
-    {
-        if ($class instanceof PHPClass) {
-            $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);
-        } else {
-            $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($method->name);
-        }
-        $stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
-        /** @var PHPParameter $stubOptionalParameter */
-        $stubOptionalParameter = array_pop($stubParameters);
-        $reflectionValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($parameter->defaultValue);
-        $stubValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($stubOptionalParameter->defaultValue, $class);
-        self::assertEquals(
-            $reflectionValue,
-            $stubValue,
-            sprintf(
-                'Reflection method %s::%s has optional parameter %s with default value %s but stub parameter has value %s',
-                $class->name,
-                $method->name,
-                $parameter->name,
-                $reflectionValue,
-                $stubValue
-            )
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersWithDefaultValueProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testMethodsDefaultParametersValue(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
+	{
+		if ($class instanceof PHPClass) {
+			$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);
+		} else {
+			$phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($class->name)->getMethod($method->name);
+		}
+		$stubParameters = array_filter($phpstormFunction->parameters, fn (PHPParameter $stubParameter) => $stubParameter->indexInSignature === $parameter->indexInSignature);
+		/** @var PHPParameter $stubOptionalParameter */
+		$stubOptionalParameter = array_pop($stubParameters);
+		$reflectionValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($parameter->defaultValue);
+		$stubValue = BaseStubsTest::getStringRepresentationOfDefaultParameterValue($stubOptionalParameter->defaultValue, $class);
+		self::assertEquals(
+			$reflectionValue,
+			$stubValue,
+			sprintf(
+				'Reflection method %s::%s has optional parameter %s with default value %s but stub parameter has value %s',
+				$class->name,
+				$method->name,
+				$parameter->name,
+				$reflectionValue,
+				$stubValue
+			)
+		);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -60,7 +60,7 @@
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionParametersProvider::methodOptionalParametersWithDefaultValueProvider
      * @throws Exception|RuntimeException
      */
-    public function testMethodsDefaultParametersValue(PHPClass|PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
+    public function testMethodsDefaultParametersValue(PHPClass | PHPInterface $class, PHPMethod $method, PHPParameter $parameter)
     {
         if ($class instanceof PHPClass) {
             $phpstormFunction = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getMethod($method->name);

Braces +1 added lines, -2 removed lines

@@ -13,8 +13,7 @@
 use StubTests\Model\PHPParameter;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class StubsConstantsAndParametersValuesTest extends BaseStubsTest
-{
+class StubsConstantsAndParametersValuesTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionConstantsProvider::constantValuesProvider
      */

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

Indentation +67 added lines, -67 removed lines

@@ -15,75 +15,75 @@
 
 class StubsMetaInternalTagTest extends BaseStubsTest
 {
-    /**
-     * @var string[]
-     */
-    private static array $overriddenFunctionsInMeta;
+	/**
+	 * @var string[]
+	 */
+	private static array $overriddenFunctionsInMeta;
 
-    public static function setUpBeforeClass(): void
-    {
-        parent::setUpBeforeClass();
-        self::$overriddenFunctionsInMeta = (new MetaOverrideFunctionsParser())->overridenFunctions;
-    }
+	public static function setUpBeforeClass(): void
+	{
+		parent::setUpBeforeClass();
+		self::$overriddenFunctionsInMeta = (new MetaOverrideFunctionsParser())->overridenFunctions;
+	}
 
-    /**
-     * @throws Exception
-     */
-    public function testFunctionInternalMetaTag(): void
-    {
-        $functions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
-        foreach ($functions as $function) {
-            if ($function->hasInternalMetaTag) {
-                $reflectionFunctions = array_filter(
-                    ReflectionStubsSingleton::getReflectionStubs()->getFunctions(),
-                    fn ($refFunction) => $refFunction->name === $function->name
-                );
-                $reflectionFunction = array_pop($reflectionFunctions);
-                if ($reflectionFunction !== null && !$reflectionFunction->hasMutedProblem(StubProblemType::ABSENT_IN_META)) {
-                    self::checkInternalMetaInOverride($function->name);
-                }
-            }
-        }
-    }
+	/**
+	 * @throws Exception
+	 */
+	public function testFunctionInternalMetaTag(): void
+	{
+		$functions = PhpStormStubsSingleton::getPhpStormStubs()->getFunctions();
+		foreach ($functions as $function) {
+			if ($function->hasInternalMetaTag) {
+				$reflectionFunctions = array_filter(
+					ReflectionStubsSingleton::getReflectionStubs()->getFunctions(),
+					fn ($refFunction) => $refFunction->name === $function->name
+				);
+				$reflectionFunction = array_pop($reflectionFunctions);
+				if ($reflectionFunction !== null && !$reflectionFunction->hasMutedProblem(StubProblemType::ABSENT_IN_META)) {
+					self::checkInternalMetaInOverride($function->name);
+				}
+			}
+		}
+	}
 
-    /**
-     * @throws RuntimeException
-     */
-    public function testMethodsInternalMetaTag(): void
-    {
-        foreach (PhpStormStubsSingleton::getPhpStormStubs()->getClasses() as $className => $class) {
-            foreach ($class->methods as $methodName => $method) {
-                if ($method->hasInternalMetaTag) {
-                    $refClass = ReflectionStubsSingleton::getReflectionStubs()->getClass($className);
-                    if ($refClass !== null) {
-                        $reflectionMethods = array_filter(
-                            $refClass->methods,
-                            fn ($refMethod) => $refMethod->name === $methodName
-                        );
-                        /** @var PHPMethod $reflectionMethod */
-                        $reflectionMethod = array_pop($reflectionMethods);
-                        if ($reflectionMethod->hasMutedProblem(StubProblemType::ABSENT_IN_META)) {
-                            static::markTestSkipped('method intentionally not added to meta');
-                        } else {
-                            self::checkInternalMetaInOverride($className . '::' . $methodName);
-                        }
-                    }
-                } else {
-                    $this->expectNotToPerformAssertions();
-                }
-            }
-        }
-    }
+	/**
+	 * @throws RuntimeException
+	 */
+	public function testMethodsInternalMetaTag(): void
+	{
+		foreach (PhpStormStubsSingleton::getPhpStormStubs()->getClasses() as $className => $class) {
+			foreach ($class->methods as $methodName => $method) {
+				if ($method->hasInternalMetaTag) {
+					$refClass = ReflectionStubsSingleton::getReflectionStubs()->getClass($className);
+					if ($refClass !== null) {
+						$reflectionMethods = array_filter(
+							$refClass->methods,
+							fn ($refMethod) => $refMethod->name === $methodName
+						);
+						/** @var PHPMethod $reflectionMethod */
+						$reflectionMethod = array_pop($reflectionMethods);
+						if ($reflectionMethod->hasMutedProblem(StubProblemType::ABSENT_IN_META)) {
+							static::markTestSkipped('method intentionally not added to meta');
+						} else {
+							self::checkInternalMetaInOverride($className . '::' . $methodName);
+						}
+					}
+				} else {
+					$this->expectNotToPerformAssertions();
+				}
+			}
+		}
+	}
 
-    /**
-     * @throws Exception
-     */
-    private static function checkInternalMetaInOverride(string $elementName): void
-    {
-        self::assertContains(
-            $elementName,
-            self::$overriddenFunctionsInMeta,
-            "$elementName contains @meta in phpdoc but isn't added to 'override()' functions in meta file"
-        );
-    }
+	/**
+	 * @throws Exception
+	 */
+	private static function checkInternalMetaInOverride(string $elementName): void
+	{
+		self::assertContains(
+			$elementName,
+			self::$overriddenFunctionsInMeta,
+			"$elementName contains @meta in phpdoc but isn't added to 'override()' functions in meta file"
+		);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -65,7 +65,7 @@
                         if ($reflectionMethod->hasMutedProblem(StubProblemType::ABSENT_IN_META)) {
                             static::markTestSkipped('method intentionally not added to meta');
                         } else {
-                            self::checkInternalMetaInOverride($className . '::' . $methodName);
+                            self::checkInternalMetaInOverride($className.'::'.$methodName);
                         }
                     }
                 } else {

Braces +1 added lines, -2 removed lines

@@ -13,8 +13,7 @@
 use function array_filter;
 use function array_pop;
 
-class StubsMetaInternalTagTest extends BaseStubsTest
-{
+class StubsMetaInternalTagTest extends BaseStubsTest {
     /**
      * @var string[]
      */

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

Indentation +241 added lines, -241 removed lines

@@ -14,259 +14,259 @@
 
 class BaseClassesTest extends BaseStubsTest
 {
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classWithParentProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassesParent(PHPClass|PHPInterface $class)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
-            static::assertEquals(
-                $class->parentClass,
-                $stubClass->parentClass,
-                empty($class->parentClass) ? "Class $className should not extend $stubClass->parentClass" :
-                    "Class $className should extend $class->parentClass"
-            );
-        } else {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
-            foreach ($class->parentInterfaces as $parentInterface) {
-                static::assertContains(
-                    $parentInterface,
-                    $stubClass->parentInterfaces,
-                    "Interface $className should extend $parentInterface"
-                );
-            }
-        }
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classWithParentProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassesParent(PHPClass|PHPInterface $class)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
+			static::assertEquals(
+				$class->parentClass,
+				$stubClass->parentClass,
+				empty($class->parentClass) ? "Class $className should not extend $stubClass->parentClass" :
+					"Class $className should extend $class->parentClass"
+			);
+		} else {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
+			foreach ($class->parentInterfaces as $parentInterface) {
+				static::assertContains(
+					$parentInterface,
+					$stubClass->parentInterfaces,
+					"Interface $className should extend $parentInterface"
+				);
+			}
+		}
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassesMethodsExist(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
-        } else {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
-        }
-        static::assertNotEmpty($stubClass->getMethod($method->name), "Missing method $className::$method->name");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassesMethodsExist(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
+		} else {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
+		}
+		static::assertNotEmpty($stubClass->getMethod($method->name), "Missing method $className::$method->name");
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classFinalMethodsProvider
-     * @throws RuntimeException
-     */
-    public function testClassesFinalMethods(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
-        }
-        static::assertEquals(
-            $method->isFinal,
-            $stubMethod->isFinal,
-            "Method $className::$method->name final modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classFinalMethodsProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassesFinalMethods(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
+		}
+		static::assertEquals(
+			$method->isFinal,
+			$stubMethod->isFinal,
+			"Method $className::$method->name final modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classStaticMethodsProvider
-     * @throws RuntimeException
-     */
-    public function testClassesStaticMethods(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
-        }
-        static::assertEquals(
-            $method->isStatic,
-            $stubMethod->isStatic,
-            "Method $className::$method->name static modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classStaticMethodsProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassesStaticMethods(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
+		}
+		static::assertEquals(
+			$method->isStatic,
+			$stubMethod->isStatic,
+			"Method $className::$method->name static modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithAccessProvider
-     * @throws RuntimeException
-     */
-    public function testClassesMethodsVisibility(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
-        }
-        static::assertEquals(
-            $method->access,
-            $stubMethod->access,
-            "Method $className::$method->name access modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithAccessProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassesMethodsVisibility(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
+		}
+		static::assertEquals(
+			$method->access,
+			$stubMethod->access,
+			"Method $className::$method->name access modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithParametersProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassMethodsParametersCount(PHPClass|PHPInterface $class, PHPMethod $method)
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
-        } else {
-            $stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
-        }
-        $filteredStubParameters = array_filter(
-            $stubMethod->parameters,
-            function ($parameter) {
-                if (!empty($parameter->availableVersionsRangeFromAttribute)) {
-                    return $parameter->availableVersionsRangeFromAttribute['from'] <= (doubleval(getenv('PHP_VERSION') ?? PhpVersions::getFirst()))
-                        && $parameter->availableVersionsRangeFromAttribute['to'] >= (doubleval(getenv('PHP_VERSION')) ?? PhpVersions::getLatest());
-                } else {
-                    return true;
-                }
-            }
-        );
-        static::assertSameSize(
-            $method->parameters,
-            $filteredStubParameters,
-            "Parameter number mismatch for method $className::$method->name. 
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithParametersProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassMethodsParametersCount(PHPClass|PHPInterface $class, PHPMethod $method)
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className)->getMethod($method->name);
+		} else {
+			$stubMethod = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className)->getMethod($method->name);
+		}
+		$filteredStubParameters = array_filter(
+			$stubMethod->parameters,
+			function ($parameter) {
+				if (!empty($parameter->availableVersionsRangeFromAttribute)) {
+					return $parameter->availableVersionsRangeFromAttribute['from'] <= (doubleval(getenv('PHP_VERSION') ?? PhpVersions::getFirst()))
+						&& $parameter->availableVersionsRangeFromAttribute['to'] >= (doubleval(getenv('PHP_VERSION')) ?? PhpVersions::getLatest());
+				} else {
+					return true;
+				}
+			}
+		);
+		static::assertSameSize(
+			$method->parameters,
+			$filteredStubParameters,
+			"Parameter number mismatch for method $className::$method->name. 
                          Expected: " . self::getParameterRepresentation($method)
-        );
-    }
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classesWithInterfacesProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassInterfaces(PHPClass $class)
-    {
-        $className = $class->name;
-        $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name, shouldSuitCurrentPhpVersion: false);
-        foreach ($class->interfaces as $interface) {
-            static::assertContains(
-                $interface,
-                $stubClass->interfaces,
-                "Class $className doesn't implement interface $interface"
-            );
-        }
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classesWithInterfacesProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassInterfaces(PHPClass $class)
+	{
+		$className = $class->name;
+		$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name, shouldSuitCurrentPhpVersion: false);
+		foreach ($class->interfaces as $interface) {
+			static::assertContains(
+				$interface,
+				$stubClass->interfaces,
+				"Class $className doesn't implement interface $interface"
+			);
+		}
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassProperties(PHPClass $class, PHPProperty $property)
-    {
-        $className = $class->name;
-        $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name);
-        static::assertNotEmpty($stubClass->getProperty($property->name), "Missing property $property->access "
-            . implode('|', $property->typesFromSignature) .
-            "$className::$$property->name");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassProperties(PHPClass $class, PHPProperty $property)
+	{
+		$className = $class->name;
+		$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name);
+		static::assertNotEmpty($stubClass->getProperty($property->name), "Missing property $property->access "
+			. implode('|', $property->typesFromSignature) .
+			"$className::$$property->name");
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classStaticPropertiesProvider
-     * @throws RuntimeException
-     */
-    public function testClassStaticProperties(PHPClass $class, PHPProperty $property)
-    {
-        $className = $class->name;
-        $stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
-        static::assertEquals(
-            $property->is_static,
-            $stubProperty->is_static,
-            "Property $className::$property->name static modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classStaticPropertiesProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassStaticProperties(PHPClass $class, PHPProperty $property)
+	{
+		$className = $class->name;
+		$stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
+		static::assertEquals(
+			$property->is_static,
+			$stubProperty->is_static,
+			"Property $className::$property->name static modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesWithAccessProvider
-     * @throws RuntimeException
-     */
-    public function testClassPropertiesVisibility(PHPClass $class, PHPProperty $property)
-    {
-        $className = $class->name;
-        $stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
-        static::assertEquals(
-            $property->access,
-            $stubProperty->access,
-            "Property $className::$property->name access modifier is incorrect"
-        );
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesWithAccessProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassPropertiesVisibility(PHPClass $class, PHPProperty $property)
+	{
+		$className = $class->name;
+		$stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
+		static::assertEquals(
+			$property->access,
+			$stubProperty->access,
+			"Property $className::$property->name access modifier is incorrect"
+		);
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesWithTypeProvider
-     * @throws RuntimeException
-     */
-    public function testClassPropertiesType(PHPClass $class, PHPProperty $property)
-    {
-        $className = $class->name;
-        $stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
-        $propertyName = $stubProperty->name;
-        $unifiedStubsPropertyTypes = [];
-        $unifiedStubsAttributesPropertyTypes = [];
-        $unifiedReflectionPropertyTypes = [];
-        self::convertNullableTypesToUnion($property->typesFromSignature, $unifiedReflectionPropertyTypes);
-        if (!empty($stubProperty->typesFromSignature)) {
-            self::convertNullableTypesToUnion($stubProperty->typesFromSignature, $unifiedStubsPropertyTypes);
-        }
-        foreach ($stubProperty->typesFromAttribute as $languageVersion => $listOfTypes) {
-            $unifiedStubsAttributesPropertyTypes[$languageVersion] = [];
-            self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesPropertyTypes[$languageVersion]);
-        }
-        $typesFromAttribute = [];
-        $testCondition = self::isReflectionTypesMatchSignature($unifiedReflectionPropertyTypes, $unifiedStubsPropertyTypes);
-        if (!$testCondition) {
-            if (!empty($unifiedStubsAttributesPropertyTypes)) {
-                $typesFromAttribute = !empty($unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')]) ?
-                    $unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')] :
-                    $unifiedStubsAttributesPropertyTypes['default'];
-                $testCondition = self::isReflectionTypesExistInAttributes($unifiedReflectionPropertyTypes, $typesFromAttribute);
-            }
-        }
-        self::assertTrue($testCondition, "Property $className::$propertyName has invalid typehint.
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionPropertiesProvider::classPropertiesWithTypeProvider
+	 * @throws RuntimeException
+	 */
+	public function testClassPropertiesType(PHPClass $class, PHPProperty $property)
+	{
+		$className = $class->name;
+		$stubProperty = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name)->getProperty($property->name);
+		$propertyName = $stubProperty->name;
+		$unifiedStubsPropertyTypes = [];
+		$unifiedStubsAttributesPropertyTypes = [];
+		$unifiedReflectionPropertyTypes = [];
+		self::convertNullableTypesToUnion($property->typesFromSignature, $unifiedReflectionPropertyTypes);
+		if (!empty($stubProperty->typesFromSignature)) {
+			self::convertNullableTypesToUnion($stubProperty->typesFromSignature, $unifiedStubsPropertyTypes);
+		}
+		foreach ($stubProperty->typesFromAttribute as $languageVersion => $listOfTypes) {
+			$unifiedStubsAttributesPropertyTypes[$languageVersion] = [];
+			self::convertNullableTypesToUnion($listOfTypes, $unifiedStubsAttributesPropertyTypes[$languageVersion]);
+		}
+		$typesFromAttribute = [];
+		$testCondition = self::isReflectionTypesMatchSignature($unifiedReflectionPropertyTypes, $unifiedStubsPropertyTypes);
+		if (!$testCondition) {
+			if (!empty($unifiedStubsAttributesPropertyTypes)) {
+				$typesFromAttribute = !empty($unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')]) ?
+					$unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')] :
+					$unifiedStubsAttributesPropertyTypes['default'];
+				$testCondition = self::isReflectionTypesExistInAttributes($unifiedReflectionPropertyTypes, $typesFromAttribute);
+			}
+		}
+		self::assertTrue($testCondition, "Property $className::$propertyName has invalid typehint.
         Reflection property has type " . implode('|', $unifiedReflectionPropertyTypes) . ' but stubs has type ' .
-            implode('|', $unifiedStubsPropertyTypes) . ' in signature and attribute has types ' .
-            implode('|', $typesFromAttribute));
-    }
+			implode('|', $unifiedStubsPropertyTypes) . ' in signature and attribute has types ' .
+			implode('|', $typesFromAttribute));
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::allClassesProvider
-     * @throws Exception
-     */
-    public function testClassesExist(PHPClass|PHPInterface $class): void
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
-        } else {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
-        }
-        static::assertNotEmpty($stubClass, "Missing class $className: class $className {}");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::allClassesProvider
+	 * @throws Exception
+	 */
+	public function testClassesExist(PHPClass|PHPInterface $class): void
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
+		} else {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
+		}
+		static::assertNotEmpty($stubClass, "Missing class $className: class $className {}");
+	}
 
-    /**
-     * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::finalClassesProvider
-     * @throws Exception|RuntimeException
-     */
-    public function testClassesFinal(PHPClass|PHPInterface $class): void
-    {
-        $className = $class->name;
-        if ($class instanceof PHPClass) {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
-        } else {
-            $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
-        }
-        static::assertEquals($class->isFinal, $stubClass->isFinal, "Final modifier of class $className is incorrect");
-    }
+	/**
+	 * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::finalClassesProvider
+	 * @throws Exception|RuntimeException
+	 */
+	public function testClassesFinal(PHPClass|PHPInterface $class): void
+	{
+		$className = $class->name;
+		if ($class instanceof PHPClass) {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($className);
+		} else {
+			$stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
+		}
+		static::assertEquals($class->isFinal, $stubClass->isFinal, "Final modifier of class $className is incorrect");
+	}
 }

Spacing +15 added lines, -17 removed lines

@@ -18,7 +18,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classWithParentProvider
      * @throws Exception|RuntimeException
      */
-    public function testClassesParent(PHPClass|PHPInterface $class)
+    public function testClassesParent(PHPClass | PHPInterface $class)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -26,8 +26,7 @@ 
             static::assertEquals(
                 $class->parentClass,
                 $stubClass->parentClass,
-                empty($class->parentClass) ? "Class $className should not extend $stubClass->parentClass" :
-                    "Class $className should extend $class->parentClass"
+                empty($class->parentClass) ? "Class $className should not extend $stubClass->parentClass" : "Class $className should extend $class->parentClass"
             );
         } else {
             $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getInterface($className);
@@ -45,7 +44,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsProvider
      * @throws Exception|RuntimeException
      */
-    public function testClassesMethodsExist(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testClassesMethodsExist(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -60,7 +59,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classFinalMethodsProvider
      * @throws RuntimeException
      */
-    public function testClassesFinalMethods(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testClassesFinalMethods(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -79,7 +78,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classStaticMethodsProvider
      * @throws RuntimeException
      */
-    public function testClassesStaticMethods(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testClassesStaticMethods(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -98,7 +97,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithAccessProvider
      * @throws RuntimeException
      */
-    public function testClassesMethodsVisibility(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testClassesMethodsVisibility(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -117,7 +116,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionMethodsProvider::classMethodsWithParametersProvider
      * @throws Exception|RuntimeException
      */
-    public function testClassMethodsParametersCount(PHPClass|PHPInterface $class, PHPMethod $method)
+    public function testClassMethodsParametersCount(PHPClass | PHPInterface $class, PHPMethod $method)
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -127,7 +126,7 @@ 
         }
         $filteredStubParameters = array_filter(
             $stubMethod->parameters,
-            function ($parameter) {
+            function($parameter) {
                 if (!empty($parameter->availableVersionsRangeFromAttribute)) {
                     return $parameter->availableVersionsRangeFromAttribute['from'] <= (doubleval(getenv('PHP_VERSION') ?? PhpVersions::getFirst()))
                         && $parameter->availableVersionsRangeFromAttribute['to'] >= (doubleval(getenv('PHP_VERSION')) ?? PhpVersions::getLatest());
@@ -140,7 +139,7 @@ 
             $method->parameters,
             $filteredStubParameters,
             "Parameter number mismatch for method $className::$method->name. 
-                         Expected: " . self::getParameterRepresentation($method)
+                         Expected: ".self::getParameterRepresentation($method)
         );
     }
 
@@ -170,7 +169,7 @@ 
         $className = $class->name;
         $stubClass = PhpStormStubsSingleton::getPhpStormStubs()->getClass($class->name);
         static::assertNotEmpty($stubClass->getProperty($property->name), "Missing property $property->access "
-            . implode('|', $property->typesFromSignature) .
+            . implode('|', $property->typesFromSignature).
             "$className::$$property->name");
     }
 
@@ -229,14 +228,13 @@ 
         if (!$testCondition) {
             if (!empty($unifiedStubsAttributesPropertyTypes)) {
                 $typesFromAttribute = !empty($unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')]) ?
-                    $unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')] :
-                    $unifiedStubsAttributesPropertyTypes['default'];
+                    $unifiedStubsAttributesPropertyTypes[getenv('PHP_VERSION')] : $unifiedStubsAttributesPropertyTypes['default'];
                 $testCondition = self::isReflectionTypesExistInAttributes($unifiedReflectionPropertyTypes, $typesFromAttribute);
             }
         }
         self::assertTrue($testCondition, "Property $className::$propertyName has invalid typehint.
-        Reflection property has type " . implode('|', $unifiedReflectionPropertyTypes) . ' but stubs has type ' .
-            implode('|', $unifiedStubsPropertyTypes) . ' in signature and attribute has types ' .
+        Reflection property has type ".implode('|', $unifiedReflectionPropertyTypes).' but stubs has type '.
+            implode('|', $unifiedStubsPropertyTypes).' in signature and attribute has types '.
             implode('|', $typesFromAttribute));
     }
 
@@ -244,7 +242,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::allClassesProvider
      * @throws Exception
      */
-    public function testClassesExist(PHPClass|PHPInterface $class): void
+    public function testClassesExist(PHPClass | PHPInterface $class): void
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {
@@ -259,7 +257,7 @@ 
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::finalClassesProvider
      * @throws Exception|RuntimeException
      */
-    public function testClassesFinal(PHPClass|PHPInterface $class): void
+    public function testClassesFinal(PHPClass | PHPInterface $class): void
     {
         $className = $class->name;
         if ($class instanceof PHPClass) {

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
 use StubTests\Model\PhpVersions;
 use StubTests\TestData\Providers\PhpStormStubsSingleton;
 
-class BaseClassesTest extends BaseStubsTest
-{
+class BaseClassesTest extends BaseStubsTest {
     /**
      * @dataProvider \StubTests\TestData\Providers\Reflection\ReflectionClassesTestDataProviders::classWithParentProvider
      * @throws Exception|RuntimeException

vendor-bin/php-scoper/vendor/jetbrains/phpstorm-stubs/tests/CodeStyle/BracesOneLineFixer.php

Indentation +59 added lines, -59 removed lines

@@ -14,74 +14,74 @@
 
 final class BracesOneLineFixer implements FixerInterface
 {
-    public function isCandidate(Tokens $tokens): bool
-    {
-        return true;
-    }
+	public function isCandidate(Tokens $tokens): bool
+	{
+		return true;
+	}
 
-    public function isRisky(): bool
-    {
-        return false;
-    }
+	public function isRisky(): bool
+	{
+		return false;
+	}
 
-    public function fix(SplFileInfo $file, Tokens $tokens): void
-    {
-        /**
-         * @var Token $token
-         */
-        foreach ($tokens as $index => $token) {
-            if (!$token->equals('{')) {
-                continue;
-            }
-            $braceStartIndex = $index;
-            $braceEndIndex = $tokens->getNextMeaningfulToken($index);
+	public function fix(SplFileInfo $file, Tokens $tokens): void
+	{
+		/**
+		 * @var Token $token
+		 */
+		foreach ($tokens as $index => $token) {
+			if (!$token->equals('{')) {
+				continue;
+			}
+			$braceStartIndex = $index;
+			$braceEndIndex = $tokens->getNextMeaningfulToken($index);
 
-            $token = $tokens[$braceEndIndex];
-            if ($token->equals('}')) {
-                $beforeBraceIndex = $tokens->getPrevNonWhitespace($braceStartIndex);
-                for ($i = $beforeBraceIndex + 1; $i <= $braceEndIndex; $i++) {
-                    $tokens->clearAt($i);
-                }
-                if ($braceEndIndex - $beforeBraceIndex > 2) {
-                    $tokens[$beforeBraceIndex + 1] = new Token(' ');
-                } else {
-                    $tokens->insertAt($beforeBraceIndex + 1, new Token(' '));
-                }
-                $tokens[$beforeBraceIndex + 2] = new Token('{');
-                $tokens[$beforeBraceIndex + 3] = new Token('}');
-            }
-        }
-    }
+			$token = $tokens[$braceEndIndex];
+			if ($token->equals('}')) {
+				$beforeBraceIndex = $tokens->getPrevNonWhitespace($braceStartIndex);
+				for ($i = $beforeBraceIndex + 1; $i <= $braceEndIndex; $i++) {
+					$tokens->clearAt($i);
+				}
+				if ($braceEndIndex - $beforeBraceIndex > 2) {
+					$tokens[$beforeBraceIndex + 1] = new Token(' ');
+				} else {
+					$tokens->insertAt($beforeBraceIndex + 1, new Token(' '));
+				}
+				$tokens[$beforeBraceIndex + 2] = new Token('{');
+				$tokens[$beforeBraceIndex + 3] = new Token('}');
+			}
+		}
+	}
 
-    public function getName(): string
-    {
-        return 'PhpStorm/braces_one_line';
-    }
+	public function getName(): string
+	{
+		return 'PhpStorm/braces_one_line';
+	}
 
-    public function getPriority(): int
-    {
-        return 0;
-    }
+	public function getPriority(): int
+	{
+		return 0;
+	}
 
-    public function supports(SplFileInfo $file): bool
-    {
-        return true;
-    }
+	public function supports(SplFileInfo $file): bool
+	{
+		return true;
+	}
 
-    #[Pure]
-    public function getDefinition(): FixerDefinitionInterface
-    {
-        return new FixerDefinition(
-            "Braces of empty function's body should be placed on the same line",
-            [
-                new CodeSample(
-                    <<<PHP
+	#[Pure]
+	public function getDefinition(): FixerDefinitionInterface
+	{
+		return new FixerDefinition(
+			"Braces of empty function's body should be placed on the same line",
+			[
+				new CodeSample(
+					<<<PHP
 <?php
 declare(strict_types=1);
 function foo() {}
 PHP
-                ),
-            ]
-        );
-    }
+				),
+			]
+		);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
 use PhpCsFixer\Tokenizer\Tokens;
 use SplFileInfo;
 
-final class BracesOneLineFixer implements FixerInterface
-{
+final class BracesOneLineFixer implements FixerInterface {
     public function isCandidate(Tokens $tokens): bool
     {
         return true;