[DX] Type of class method/class const cannot be checked, use Class_ instead (#6281)

* improve WrapReturnRector to hook directly the class

* Make ChangeConstantVisibilityRector hook to class to detect type easily

* object type on class method or class const cannot be checked, add warning

* Remove ClassMethodOrClassConstTypeResolver as unused

Author: TomasVotruba

rules/Transform/Rector/ClassMethod/WrapReturnRector.php

@@ -8,6 +8,7 @@
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\ArrayItem;
+use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Return_;
 use Rector\Contract\Rector\ConfigurableRectorInterface;
@@ -61,28 +62,37 @@ public function getItem()
      */
     public function getNodeTypes(): array
     {
-        return [ClassMethod::class];
+        return [Class_::class];
     }
 
     /**
-     * @param ClassMethod $node
+     * @param Class_ $node
      */
     public function refactor(Node $node): ?Node
     {
-        foreach ($this->typeMethodWraps as $typeMethodWrap) {
-            if (! $this->isName($node, $typeMethodWrap->getMethod())) {
-                continue;
-            }
+        $hasChanged = false;
 
+        foreach ($this->typeMethodWraps as $typeMethodWrap) {
             if (! $this->isObjectType($node, $typeMethodWrap->getObjectType())) {
                 continue;
             }
 
-            if ($node->stmts === null) {
-                continue;
+            foreach ($node->getMethods() as $classMethod) {
+                if (! $this->isName($classMethod, $typeMethodWrap->getMethod())) {
+                    continue;
+                }
+
+                if ($node->stmts === null) {
+                    continue;
+                }
+
+                $this->wrap($classMethod, $typeMethodWrap->isArrayWrap());
+                $hasChanged = true;
             }
+        }
 
-            return $this->wrap($node, $typeMethodWrap->isArrayWrap());
+        if ($hasChanged) {
+            return $node;
         }
 
         return null;

rules/Visibility/Rector/ClassConst/ChangeConstantVisibilityRector.php

@@ -5,7 +5,8 @@
 namespace Rector\Visibility\Rector\ClassConst;
 
 use PhpParser\Node;
-use PhpParser\Node\Stmt\ClassConst;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\Interface_;
 use Rector\Contract\Rector\ConfigurableRectorInterface;
 use Rector\Privatization\NodeManipulator\VisibilityManipulator;
 use Rector\Rector\AbstractRector;
@@ -71,25 +72,35 @@ class MyClass extends FrameworkClass
      */
     public function getNodeTypes(): array
     {
-        return [ClassConst::class];
+        return [Class_::class, Interface_::class];
     }
 
     /**
-     * @param ClassConst $node
+     * @param Class_|Interface_ $node
      */
     public function refactor(Node $node): ?Node
     {
-        foreach ($this->classConstantVisibilityChanges as $classConstantVisibilityChange) {
-            if (! $this->isName($node, $classConstantVisibilityChange->getConstant())) {
-                continue;
-            }
+        $hasChanged = false;
 
+        foreach ($this->classConstantVisibilityChanges as $classConstantVisibilityChange) {
             if (! $this->isObjectType($node, $classConstantVisibilityChange->getObjectType())) {
                 continue;
             }
 
-            $this->visibilityManipulator->changeNodeVisibility($node, $classConstantVisibilityChange->getVisibility());
+            foreach ($node->getConstants() as $classConst) {
+                if (! $this->isName($classConst, $classConstantVisibilityChange->getConstant())) {
+                    continue;
+                }
+
+                $this->visibilityManipulator->changeNodeVisibility(
+                    $classConst,
+                    $classConstantVisibilityChange->getVisibility()
+                );
+                $hasChanged = true;
+            }
+        }
 
+        if ($hasChanged) {
             return $node;
         }
 

src/DependencyInjection/LazyContainerFactory.php

@@ -79,7 +79,6 @@
 use Rector\NodeTypeResolver\NodeTypeResolver\CastTypeResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver\ClassAndInterfaceTypeResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver\ClassConstFetchTypeResolver;
-use Rector\NodeTypeResolver\NodeTypeResolver\ClassMethodOrClassConstTypeResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver\IdentifierTypeResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver\NameTypeResolver;
 use Rector\NodeTypeResolver\NodeTypeResolver\NewTypeResolver;
@@ -335,7 +334,6 @@ final class LazyContainerFactory
         CastTypeResolver::class,
         StaticCallMethodCallTypeResolver::class,
         ClassAndInterfaceTypeResolver::class,
-        ClassMethodOrClassConstTypeResolver::class,
         IdentifierTypeResolver::class,
         NameTypeResolver::class,
         NewTypeResolver::class,

src/NodeTypeResolver/NodeTypeResolver.php

@@ -16,6 +16,8 @@
 use PhpParser\Node\Expr\Ternary;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt\ClassConst;
+use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\UnionType as NodeUnionType;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\ClassAutoloadingException;
@@ -36,6 +38,7 @@
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\UnionType;
 use Rector\Configuration\RenamedClassesDataCollector;
+use Rector\Exception\ShouldNotHappenException;
 use Rector\NodeAnalyzer\ClassAnalyzer;
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverAwareInterface;
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverInterface;
@@ -98,6 +101,19 @@ public function isObjectType(Node $node, ObjectType $requiredObjectType): bool
             return false;
         }
 
+        // warn about invalid use of this method
+        if ($node instanceof ClassMethod) {
+            throw new ShouldNotHappenException(
+                'ClassMethod itself does not have any type. Check the Class_/Interface/Trait_ node instead'
+            );
+        }
+
+        if ($node instanceof ClassConst) {
+            throw new ShouldNotHappenException(
+                'Class constant itself does not have any type. Check the Class_/Trait_ instead'
+            );
+        }
+
         $resolvedType = $this->getType($node);
         if ($resolvedType instanceof MixedType) {
             return false;