run phpstan

packages/BetterPhpDocParser/PhpDocInfo/PhpDocInfo.php

@@ -26,7 +26,6 @@
 use Rector\Core\Configuration\CurrentNodeProvider;
 use Rector\Core\Exception\NotImplementedYetException;
 use Rector\Core\Exception\ShouldNotHappenException;
-use Rector\Core\Util\StaticInstanceOf;
 use Rector\StaticTypeMapper\StaticTypeMapper;
 
 /**
@@ -486,16 +485,21 @@ private function getTypeOrMixed(?PhpDocTagValueNode $phpDocTagValueNode): Type
         return $this->staticTypeMapper->mapPHPStanPhpDocTypeToPHPStanType($phpDocTagValueNode, $this->node);
     }
 
+    /**
+     * @param class-string $type
+     */
     private function ensureTypeIsTagValueNode(string $type, string $location): void
     {
-        /** @var array<class-string> $desiredTypes */
+        /** @var array<class-string<\PhpParser\Node>> $desiredTypes */
         $desiredTypes = array_merge([
             PhpDocTagValueNode::class,
             PhpDocTagNode::class,
         ], NodeTypes::TYPE_AWARE_NODES);
 
-        if (StaticInstanceOf::isOneOf($type, $desiredTypes)) {
-            return;
+        foreach ($desiredTypes as $desiredType) {
+            if (is_a($type, $desiredType, true)) {
+                return;
+            }
         }
 
         throw new ShouldNotHappenException(sprintf(
@@ -509,7 +513,8 @@ private function ensureTypeIsTagValueNode(string $type, string $location): void
     private function resolveNameForPhpDocTagValueNode(PhpDocTagValueNode $phpDocTagValueNode): string
     {
         foreach (self::TAGS_TYPES_TO_NAMES as $tagValueNodeType => $name) {
-            if ($phpDocTagValueNode instanceof $tagValueNodeType) {
+            /** @var class-string<PhpDocTagNode> $tagValueNodeType */
+            if (is_a($phpDocTagValueNode, $tagValueNodeType, true)) {
                 return $name;
             }
         }

packages/NodeCollector/NodeCollector/ParsedNodeCollector.php

@@ -167,6 +167,7 @@ public function findClassConstant(string $className, string $constantName): ?Cla
     public function isCollectableNode(Node $node): bool
     {
         foreach (self::COLLECTABLE_NODE_TYPES as $collectableNodeType) {
+            /** @var class-string<Node> $collectableNodeType */
             if (is_a($node, $collectableNodeType, true)) {
                 return true;
             }

packages/NodeCollector/NodeCollector/ParsedPropertyFetchNodeCollector.php

@@ -13,7 +13,7 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\UnionType;
-use Rector\Core\Util\StaticInstanceOf;
+use Rector\Core\Util\StaticNodeInstanceOf;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver;
 
@@ -55,7 +55,7 @@ public function collect(Node $node): void
         }
 
         // make sure name is valid
-        if (StaticInstanceOf::isOneOf($node->name, [StaticCall::class, MethodCall::class])) {
+        if (StaticNodeInstanceOf::isOneOf($node->name, [StaticCall::class, MethodCall::class])) {
             return;
         }
 

packages/NodeNameResolver/Contract/NodeNameResolverInterface.php

@@ -8,6 +8,9 @@
 
 interface NodeNameResolverInterface
 {
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string;
 
     public function resolve(Node $node): ?string;

packages/NodeNameResolver/NodeNameResolver.php

@@ -17,7 +17,7 @@
 use Rector\Core\Contract\Rector\RectorInterface;
 use Rector\Core\Exception\ShouldNotHappenException;
 use Rector\Core\PhpParser\Printer\BetterStandardPrinter;
-use Rector\Core\Util\StaticInstanceOf;
+use Rector\Core\Util\StaticNodeInstanceOf;
 use Rector\NodeNameResolver\Contract\NodeNameResolverInterface;
 use Rector\NodeNameResolver\Regex\RegexPatternDetector;
 use Rector\NodeTypeResolver\FileSystem\CurrentFileInfoProvider;
@@ -220,7 +220,7 @@ public function matchNameFromMap(Node $node, array $renameMap): ?string
 
     private function isCallOrIdentifier(Node $node): bool
     {
-        return StaticInstanceOf::isOneOf($node, [MethodCall::class, StaticCall::class, Identifier::class]);
+        return StaticNodeInstanceOf::isOneOf($node, [MethodCall::class, StaticCall::class, Identifier::class]);
     }
 
     /**

packages/NodeNameResolver/NodeNameResolver/ClassConstFetchNameResolver.php

@@ -24,6 +24,9 @@ public function autowireClassConstFetchNameResolver(NodeNameResolver $nodeNameRe
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return ClassConstFetch::class;

packages/NodeNameResolver/NodeNameResolver/ClassConstNameResolver.php

@@ -24,6 +24,9 @@ public function autowireClassConstNameResolver(NodeNameResolver $nodeNameResolve
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return ClassConst::class;

packages/NodeNameResolver/NodeNameResolver/ClassNameResolver.php

@@ -25,6 +25,9 @@ public function autowireClassNameResolver(NodeNameResolver $nodeNameResolver): v
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return ClassLike::class;

packages/NodeNameResolver/NodeNameResolver/EmptyNameResolver.php

@@ -10,6 +10,9 @@
 
 final class EmptyNameResolver implements NodeNameResolverInterface
 {
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Empty_::class;

packages/NodeNameResolver/NodeNameResolver/FuncCallNameResolver.php

@@ -24,6 +24,9 @@ public function __construct(ReflectionProvider $reflectionProvider)
         $this->reflectionProvider = $reflectionProvider;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return FuncCall::class;

packages/NodeNameResolver/NodeNameResolver/FunctionNameResolver.php

@@ -12,6 +12,9 @@
 
 final class FunctionNameResolver implements NodeNameResolverInterface
 {
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Function_::class;

packages/NodeNameResolver/NodeNameResolver/NameNameResolver.php

@@ -23,6 +23,9 @@ public function __construct(FuncCallNameResolver $funcCallNameResolver)
         $this->funcCallNameResolver = $funcCallNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Name::class;

packages/NodeNameResolver/NodeNameResolver/ParamNameResolver.php

@@ -24,6 +24,9 @@ public function autowireParamNameResolver(NodeNameResolver $nodeNameResolver): v
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Param::class;

packages/NodeNameResolver/NodeNameResolver/PropertyNameResolver.php

@@ -24,6 +24,9 @@ public function autowirePropertyNameResolver(NodeNameResolver $nodeNameResolver)
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Property::class;

packages/NodeNameResolver/NodeNameResolver/UseNameResolver.php

@@ -24,6 +24,9 @@ public function autowireUseNameResolver(NodeNameResolver $nodeNameResolver): voi
         $this->nodeNameResolver = $nodeNameResolver;
     }
 
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Use_::class;

packages/NodeNameResolver/NodeNameResolver/VariableNameResolver.php

@@ -14,6 +14,9 @@
 
 final class VariableNameResolver implements NodeNameResolverInterface
 {
+    /**
+     * @return class-string<Node>
+     */
     public function getNode(): string
     {
         return Variable::class;

packages/NodeNestingScope/ContextAnalyzer.php

@@ -15,7 +15,7 @@
 use PhpParser\Node\Stmt\Switch_;
 use PhpParser\Node\Stmt\While_;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
-use Rector\Core\Util\StaticInstanceOf;
+use Rector\Core\Util\StaticNodeInstanceOf;
 
 final class ContextAnalyzer
 {
@@ -49,7 +49,7 @@ public function isInLoop(Node $node): bool
             return false;
         }
 
-        return StaticInstanceOf::isOneOf($firstParent, self::LOOP_NODES);
+        return StaticNodeInstanceOf::isOneOf($firstParent, self::LOOP_NODES);
     }
 
     public function isInIf(Node $node): bool

packages/NodeNestingScope/NodeFinder/ScopeAwareNodeFinder.php

@@ -48,10 +48,11 @@ public function findParentType(Node $node, array $allowedTypes): ?Node
 
     /**
      * Find node based on $callable or null, when the nesting scope is broken
-     * @param class-string[] $allowedTypes
+     * @param array<class-string<Node>> $allowedTypes
      */
     public function findParent(Node $node, callable $callable, array $allowedTypes): ?Node
     {
+        /** @var array<class-string<Node>> $parentNestingBreakTypes */
         $parentNestingBreakTypes = array_diff(ControlStructure::BREAKING_SCOPE_NODE_TYPES, $allowedTypes);
 
         $this->isBreakingNodeFoundFirst = false;

packages/NodeTypeResolver/PHPStan/Scope/PHPStanNodeScopeResolver.php

@@ -195,11 +195,7 @@ private function resolveClassOrInterfaceScope(ClassLike $classLike, Scope $scope
         return $scope->enterClass($classReflection);
     }
 
-<<<<<<< HEAD
     private function resolveDependentFiles(Node $node, MutatingScope $mutatingScope): void
-=======
-    private function resolveDependentFiles(Node $node, MutatingScope $scope): void
->>>>>>> cba12e3ab1... narrow return types
     {
         if (! $this->configuration->isCacheEnabled()) {
             return;

packages/PostRector/Collector/NodesToAddCollector.php

@@ -11,7 +11,7 @@
 use Rector\ChangesReporting\Collector\RectorChangeCollector;
 use Rector\Core\Exception\ShouldNotHappenException;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
-use Rector\Core\Util\StaticInstanceOf;
+use Rector\Core\Util\StaticNodeInstanceOf;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\PostRector\Contract\Collector\NodeCollectorInterface;
 
@@ -128,7 +128,7 @@ public function addNodesBeforeNode(array $newNodes, Node $positionNode): void
 
     private function resolveNearestExpressionPosition(Node $node): string
     {
-        if (StaticInstanceOf::isOneOf($node, [Expression::class, Stmt::class])) {
+        if (StaticNodeInstanceOf::isOneOf($node, [Expression::class, Stmt::class])) {
             return spl_object_hash($node);
         }
 

packages/StaticTypeMapper/StaticTypeMapper.php

@@ -19,7 +19,6 @@
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use Rector\Core\Exception\NotImplementedYetException;
-use Rector\Core\Util\StaticInstanceOf;
 use Rector\PHPStanStaticTypeMapper\PHPStanStaticTypeMapper;
 use Rector\StaticTypeMapper\Mapper\PhpParserNodeMapper;
 use Rector\StaticTypeMapper\Naming\NameScopeFactory;
@@ -99,11 +98,16 @@ public function mapPHPStanPhpDocTypeToPHPStanType(PhpDocTagValueNode $phpDocTagV
 
             return $this->phpDocTypeMapper->mapToPHPStanType($phpDocTagValueNode->bound, $node, $nameScope);
         }
-
-        if (StaticInstanceOf::isOneOf(
-            $phpDocTagValueNode,
-            [ReturnTagValueNode::class, ParamTagValueNode::class, VarTagValueNode::class, ThrowsTagValueNode::class]
-        )) {
+        if ($phpDocTagValueNode instanceof ReturnTagValueNode) {
+            return $this->mapPHPStanPhpDocTypeNodeToPHPStanType($phpDocTagValueNode->type, $node);
+        }
+        if ($phpDocTagValueNode instanceof ParamTagValueNode) {
+            return $this->mapPHPStanPhpDocTypeNodeToPHPStanType($phpDocTagValueNode->type, $node);
+        }
+        if ($phpDocTagValueNode instanceof VarTagValueNode) {
+            return $this->mapPHPStanPhpDocTypeNodeToPHPStanType($phpDocTagValueNode->type, $node);
+        }
+        if ($phpDocTagValueNode instanceof ThrowsTagValueNode) {
             return $this->mapPHPStanPhpDocTypeNodeToPHPStanType($phpDocTagValueNode->type, $node);
         }
 

packages/StaticTypeMapper/ValueObject/Type/ShortenedObjectType.php

@@ -4,7 +4,9 @@
 
 namespace Rector\StaticTypeMapper\ValueObject\Type;
 
+use PHPStan\TrinaryLogic;
 use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
 
 final class ShortenedObjectType extends ObjectType
 {
@@ -23,6 +25,12 @@ public function __construct(string $shortName, string $fullyQualifiedName)
         $this->fullyQualifiedName = $fullyQualifiedName;
     }
 
+    public function isSuperTypeOf(Type $type): TrinaryLogic
+    {
+        $fullyQualifiedObjectType = new ObjectType($this->fullyQualifiedName);
+        return $fullyQualifiedObjectType->isSuperTypeOf($type);
+    }
+
     public function getShortName(): string
     {
         return $this->getClassName();

phpstan.neon

@@ -519,12 +519,16 @@ parameters:
             message: '#Do not inherit from abstract class, better use composition#'
             path: utils/phpstan-extensions/src/Rule/NoInstanceOfStaticReflectionRule.php
 
-        # first wave resolved, merge PR
-        - '#Instead of "(.*?)" use ReflectionProvider service (.*?) for static reflection to work#'
-
         # known internal types on correct location
         -
             message: '#Instead of "(.*?)" use ReflectionProvider service (.*?) for static reflection to work#'
             paths:
                 - src/Application/RectorApplication.php
                 - src/Console/Command/ProcessCommand.php
+
+        # annotations
+        -
+            message: '#Instead of "instanceof/is_a\(\)" use ReflectionProvider service or "\(new ObjectType\(<desired_type\>\)\)\-\>isSuperTypeOf\(<element_type\>\)" for static reflection to work#'
+            paths:
+                - packages/BetterPhpDocParser/AnnotationReader/NodeAnnotationReader.php
+                - packages/BetterPhpDocParser/PhpDocNodeFactory/*NodeFactory.php

rules-tests/Transform/Rector/ClassMethod/SingleToManyMethodRector/Fixture/fixture.php.inc

@@ -5,7 +5,9 @@ namespace Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Fix
 use Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Source\OneToManyInterface;
 
 class SomeClass implements OneToManyInterface
-{
+{    /**
+     * @return class-string<\PhpParser\Node>
+     */
     public function getNode(): string
     {
         return 'Echo_';

rules-tests/Transform/Rector/ClassMethod/SingleToManyMethodRector/Fixture/multi_return.php.inc

@@ -5,7 +5,9 @@ namespace Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Fix
 use Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Source\OneToManyInterface;
 
 class MultiReturn implements OneToManyInterface
-{
+{    /**
+     * @return class-string<\PhpParser\Node>
+     */
     public function getNode(): string
     {
         if (true) {

rules-tests/Transform/Rector/ClassMethod/SingleToManyMethodRector/Fixture/return_class_const_fetch.php.inc

@@ -5,7 +5,9 @@ namespace Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Fix
 use Rector\Tests\Transform\Rector\ClassMethod\SingleToManyMethodRector\Source\OneToManyInterface;
 
 class ReturnClassConstFetch implements OneToManyInterface
-{
+{    /**
+     * @return class-string<\PhpParser\Node>
+     */
     public function getNode(): string
     {
         return self::class;

rules/CodeQuality/NodeAnalyzer/ForAnalyzer.php

@@ -20,7 +20,7 @@
 use Rector\Core\NodeManipulator\AssignManipulator;
 use Rector\Core\PhpParser\Comparing\NodeComparator;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
-use Rector\Core\Util\StaticInstanceOf;
+use Rector\Core\Util\StaticNodeInstanceOf;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 
@@ -105,7 +105,7 @@ public function isLoopMatch(array $loopExprs, ?string $keyValueName): bool
 
         /** @var PreInc|PostInc $prePostInc */
         $prePostInc = $loopExprs[0];
-        if (StaticInstanceOf::isOneOf($prePostInc, [PreInc::class, PostInc::class])) {
+        if (StaticNodeInstanceOf::isOneOf($prePostInc, [PreInc::class, PostInc::class])) {
             return $this->nodeNameResolver->isName($prePostInc->var, $keyValueName);
         }