move stubs to composer-autoload

composer.json

@@ -34,9 +34,9 @@
         "doctrine/annotations": "^1.12",
         "doctrine/inflector": "^2.0",
         "jean85/pretty-package-versions": "^1.5.1|^2.0.1",
-        "nette/robot-loader": "^3.2 <=3.3.1",
         "nette/utils": "^3.2",
         "nikic/php-parser": "^4.10.4",
+        "nette/robot-loader": "^3.4",
         "phpstan/phpdoc-parser": "^0.4.12",
         "phpstan/phpstan": "^0.12.81",
         "phpstan/phpstan-phpunit": "^0.12.18",
@@ -99,6 +99,7 @@
             "Rector\\Utils\\DoctrineAnnotationParserSyncer\\": "utils/doctrine-annotation-parser-syncer/src"
         },
         "classmap": [
+            "stubs/Annotations",
             "rules-tests/Autodiscovery/Rector/FileNode/MoveInterfacesToContractNamespaceDirectoryRector/Expected",
             "rules-tests/Autodiscovery/Rector/FileNode/MoveServicesBySuffixToDirectoryRector/Expected",
             "rules-tests/CakePHP/Rector/FileWithoutNamespace/ImplicitShortClassNameUseStatementRector/Source",
@@ -109,6 +110,9 @@
             "rules-tests/Symfony4/Rector/MethodCall/ContainerGetToConstructorInjectionRector/Source"
         ],
         "files": [
+            "stubs/Symfony/Component/Form/FormTypeInterface.php",
+            "stubs/Doctrine/Persistence/ObjectManager.php",
+            "stubs/Doctrine/Common/Persistence/ObjectManager.php",
             "vendor/nette/forms/src/Forms/Controls/SubmitButton.php",
             "rules-tests/Restoration/Rector/Use_/RestoreFullyQualifiedNameRector/Source/ShortClassOnly.php",
             "rules-tests/DeadCode/Rector/MethodCall/RemoveDefaultArgumentValueRector/Source/UserDefined.php",

phpstan.neon

@@ -582,3 +582,5 @@ parameters:
             message: '#Cannot cast array<string\>\|string\|null to string#'
             paths:
                 - utils/compiler/src/Command/DowngradePathsCommand.php
+
+        - '#Method Rector\\Testing\\Finder\\RectorsFinder\:\:findClassesInDirectoriesByName\(\) should return array<class\-string\> but returns array<int, string\>#'

rules-tests/PHPUnit/Rector/ClassMethod/MigrateAtToConsecutiveExpectationsRector/MigrateAtToConsecutiveExpectationsRectorTest.php

@@ -19,6 +19,9 @@ public function test(SmartFileInfo $fileInfo): void
         $this->doTestFileInfo($fileInfo);
     }
 
+    /**
+     * @return Iterator<SmartFileInfo>
+     */
     public function provideData(): Iterator
     {
         return $this->yieldFilesFromDirectory(__DIR__ . '/Fixture');

rules/PHPUnit/NodeAnalyzer/ExpectationAnalyzer.php

@@ -16,6 +16,9 @@
 
 final class ExpectationAnalyzer
 {
+    /**
+     * @var string[]
+     */
     private const PROCESSABLE_WILL_STATEMENTS = [
         'will',
         'willReturn',
@@ -74,90 +77,99 @@ public function getExpectationsFromExpressions(array $stmts): ExpectationMockCol
 
             $atArg = $expectsValue->args[0];
             $atValue = $atArg->value;
-            if ($atValue instanceof LNumber && $expects->var instanceof Variable) {
-                $expectationMockCollection->add(
-                    new ExpectationMock(
-                        $expects->var,
-                        $method->args,
-                        $atValue->value,
-                        $this->getWill($expr),
-                        $this->getWithArgs($method->var),
-                        $stmt
-                    )
-                );
+            if (! $atValue instanceof LNumber) {
+                continue;
+            }
+            if (! $expects->var instanceof Variable) {
+                continue;
             }
+
+            $expectationMockCollection->add(
+                new ExpectationMock(
+                    $expects->var,
+                    $method->args,
+                    $atValue->value,
+                    $this->getWill($expr),
+                    $this->getWithArgs($method->var),
+                    $stmt
+                )
+            );
         }
 
         return $expectationMockCollection;
     }
 
-    public function isValidExpectsCall(MethodCall $expr): bool
+    public function isValidExpectsCall(MethodCall $methodCall): bool
     {
-        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($expr, 'expects')) {
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($methodCall, 'expects')) {
             return false;
         }
 
-        if (count($expr->args) !== 1) {
+        if (count($methodCall->args) !== 1) {
             return false;
         }
 
         return true;
     }
 
-    public function isValidAtCall(MethodCall $expr): bool
+    public function isValidAtCall(MethodCall $methodCall): bool
     {
-        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($expr, 'at')) {
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($methodCall, 'at')) {
             return false;
         }
 
-        if (count($expr->args) !== 1) {
+        if (count($methodCall->args) !== 1) {
             return false;
         }
 
         return true;
     }
 
-    private function getMethod(MethodCall $expr): MethodCall
+    private function getMethod(MethodCall $methodCall): MethodCall
     {
         if ($this->testsNodeAnalyzer->isPHPUnitMethodNames(
-            $expr,
+            $methodCall,
             self::PROCESSABLE_WILL_STATEMENTS
-        ) && $expr->var instanceof MethodCall) {
-            return $expr->var;
+        ) && $methodCall->var instanceof MethodCall) {
+            return $methodCall->var;
         }
 
-        return $expr;
+        return $methodCall;
     }
 
-    private function getWill(MethodCall $expr): ?Expr
+    private function getWill(MethodCall $methodCall): ?Expr
     {
-        if (! $this->testsNodeAnalyzer->isPHPUnitMethodNames($expr, self::PROCESSABLE_WILL_STATEMENTS)) {
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodNames($methodCall, self::PROCESSABLE_WILL_STATEMENTS)) {
             return null;
         }
 
-        return $this->consecutiveAssertionFactory->createWillReturn($expr);
+        return $this->consecutiveAssertionFactory->createWillReturn($methodCall);
     }
 
-    private function getExpects(Expr $maybeWith, MethodCall $method): Expr
+    private function getExpects(Expr $expr, MethodCall $methodCall): Expr
     {
-        if ($this->testsNodeAnalyzer->isPHPUnitMethodName($maybeWith, 'with') && $maybeWith instanceof MethodCall) {
-            return $maybeWith->var;
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($expr, 'with')) {
+            return $methodCall->var;
         }
-
-        return $method->var;
+        if (! $expr instanceof MethodCall) {
+            return $methodCall->var;
+        }
+        return $expr->var;
     }
 
     /**
      * @return array<int, Expr|null>
      */
-    private function getWithArgs(Expr $maybeWith): array
+    private function getWithArgs(Expr $expr): array
     {
-        if ($this->testsNodeAnalyzer->isPHPUnitMethodName($maybeWith, 'with') && $maybeWith instanceof MethodCall) {
-            return array_map(static function (Arg $arg) {
-                return $arg->value;
-            }, $maybeWith->args);
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodName($expr, 'with')) {
+            return [null];
         }
-
-        return [null];
+        if (! $expr instanceof MethodCall) {
+            return [null];
+        }
+        return array_map(static function (Arg $arg): Expr {
+            return $arg->value;
+        }, $expr->args);
     }
 }

rules/PHPUnit/NodeFactory/ConsecutiveAssertionFactory.php

@@ -5,9 +5,11 @@
 
 use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\ArrayItem;
 use PhpParser\Node\Expr\ConstFetch;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\New_;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
@@ -17,6 +19,9 @@
 
 final class ConsecutiveAssertionFactory
 {
+    /**
+     * @var array<string, string>
+     */
     private const REPLACE_WILL_MAP = [
         'willReturnMap' => 'returnValueMap',
         'willReturnArgument' => 'returnArgument',
@@ -29,30 +34,30 @@ public function createAssertionFromExpectationMockCollection(
     ): MethodCall {
         $expectationMocks = $expectationMockCollection->getExpectationMocks();
 
-        $var = $expectationMocks[0]->getExpectationVariable();
+        $variable = $expectationMocks[0]->getExpectationVariable();
         $methodArguments = $expectationMocks[0]->getMethodArguments();
 
         $expectationMocks = $this->sortExpectationMocksByIndex($expectationMocks);
 
         if (! $expectationMockCollection->hasReturnValues()) {
             return $this->createWithConsecutive(
-                $this->createMethod($var, $methodArguments),
+                $this->createMethod($variable, $methodArguments),
                 $this->createWithArgs($expectationMocks)
             );
         }
 
         if ($expectationMockCollection->hasWithValues()) {
             return $this->createWillReturnOnConsecutiveCalls(
                 $this->createWithConsecutive(
-                    $this->createMethod($var, $methodArguments),
+                    $this->createMethod($variable, $methodArguments),
                     $this->createWithArgs($expectationMocks)
                 ),
                 $this->createReturnArgs($expectationMocks)
             );
         }
 
         return $this->createWillReturnOnConsecutiveCalls(
-            $this->createMethod($var, $methodArguments),
+            $this->createMethod($variable, $methodArguments),
             $this->createReturnArgs($expectationMocks)
         );
     }
@@ -113,7 +118,7 @@ public function createWillReturn(MethodCall $methodCall): Expr
      */
     private function createReturnArgs(array $expectationMocks): array
     {
-        return array_map(static function (ExpectationMock $expectationMock) {
+        return array_map(static function (ExpectationMock $expectationMock): Arg {
             return new Arg($expectationMock->getReturn() ?: new ConstFetch(new Name('null')));
         }, $expectationMocks);
     }
@@ -124,11 +129,11 @@ private function createReturnArgs(array $expectationMocks): array
      */
     private function createWithArgs(array $expectationMocks): array
     {
-        return array_map(static function (ExpectationMock $expectationMock) {
-            $arrayItems = array_map(static function (?Expr $expr) {
+        return array_map(static function (ExpectationMock $expectationMock): Arg {
+            $arrayItems = array_map(static function (?Expr $expr): ArrayItem {
                 return new ArrayItem($expr ?: new ConstFetch(new Name('null')));
             }, $expectationMock->getWithArguments());
-            return new Arg(new Expr\Array_($arrayItems));
+            return new Arg(new Array_($arrayItems));
         }, $expectationMocks);
     }
 
@@ -137,9 +142,9 @@ private function createWillReturnSelf(): MethodCall
         return $this->createMethodCall(new Variable('this'), 'returnSelf', []);
     }
 
-    private function createWillReturnReference(MethodCall $methodCall): Expr\New_
+    private function createWillReturnReference(MethodCall $methodCall): New_
     {
-        return new Expr\New_(
+        return new New_(
             new FullyQualified('PHPUnit\Framework\MockObject\Stub\ReturnReference'),
             [new Arg($methodCall->args[0]->value)]
         );
@@ -170,7 +175,7 @@ private function sortExpectationMocksByIndex(array $expectationMocks): array
     {
         usort(
             $expectationMocks,
-            static function (ExpectationMock $expectationMockA, ExpectationMock $expectationMockB) {
+            static function (ExpectationMock $expectationMockA, ExpectationMock $expectationMockB): int {
                 return $expectationMockA->getIndex() > $expectationMockB->getIndex() ? 1 : -1;
             }
         );