[Reflection] Add ClassReflectionProvider facade over PHPStan ReflectionProvider

rules/CodeQuality/Rector/Catch_/ThrowWithPreviousExceptionRector.php

@@ -16,11 +16,11 @@
 use PhpParser\NodeVisitor;
 use PHPStan\Reflection\ExtendedParameterReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
-use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\TypeCombinator;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Rector\StaticTypeMapper\Resolver\ClassNameFromObjectTypeResolver;
 use Rector\ValueObject\MethodName;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
@@ -34,7 +34,7 @@ final class ThrowWithPreviousExceptionRector extends AbstractRector
     private const int DEFAULT_EXCEPTION_ARGUMENT_POSITION = 2;
 
     public function __construct(
-        private readonly ReflectionProvider $reflectionProvider
+        private readonly ClassReflectionProvider $classReflectionProvider
     ) {
     }
 
@@ -219,11 +219,11 @@ private function hasParameter(New_ $new, string $parameterName): bool
             return false;
         }
 
-        if (! $this->reflectionProvider->hasClass($className)) {
+        if (! $this->classReflectionProvider->hasClass($className)) {
             return false;
         }
 
-        $classReflection = $this->reflectionProvider->getClass($className);
+        $classReflection = $this->classReflectionProvider->getClass($className);
         $construct = $classReflection->hasMethod(MethodName::CONSTRUCT);
 
         if (! $construct) {
@@ -251,11 +251,11 @@ private function hasArgument(New_ $new, string $argumentName): bool
     private function resolveExceptionArgumentPosition(Name $exceptionName): ?int
     {
         $className = $this->getName($exceptionName);
-        if (! $this->reflectionProvider->hasClass($className)) {
+        if (! $this->classReflectionProvider->hasClass($className)) {
             return self::DEFAULT_EXCEPTION_ARGUMENT_POSITION;
         }
 
-        $classReflection = $this->reflectionProvider->getClass($className);
+        $classReflection = $this->classReflectionProvider->getClass($className);
         $construct = $classReflection->hasMethod(MethodName::CONSTRUCT);
         if (! $construct) {
             return self::DEFAULT_EXCEPTION_ARGUMENT_POSITION;

rules/CodeQuality/Rector/ClassConstFetch/VariableConstFetchToClassConstFetchRector.php

@@ -9,9 +9,9 @@
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name\FullyQualified;
-use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -21,7 +21,7 @@
 final class VariableConstFetchToClassConstFetchRector extends AbstractRector
 {
     public function __construct(
-        private readonly ReflectionProvider $reflectionProvider
+        private readonly ClassReflectionProvider $classReflectionProvider
     ) {
     }
 
@@ -98,11 +98,11 @@ public function refactor(Node $node): ?ClassConstFetch
             return null;
         }
 
-        if (! $this->reflectionProvider->hasClass($classObjectType->getClassName())) {
+        if (! $this->classReflectionProvider->hasClass($classObjectType->getClassName())) {
             return null;
         }
 
-        $classReflection = $this->reflectionProvider->getClass($classObjectType->getClassName());
+        $classReflection = $this->classReflectionProvider->getClass($classObjectType->getClassName());
         if (! $classReflection->isFinalByKeyword()) {
             if (! $classReflection->hasConstant($constantName)) {
                 return null;

rules/CodeQuality/Rector/Class_/CompleteDynamicPropertiesRector.php

@@ -8,13 +8,13 @@
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt\Class_;
 use PHPStan\Reflection\ClassReflection;
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\CodeQuality\NodeAnalyzer\LocalPropertyAnalyzer;
 use Rector\CodeQuality\NodeAnalyzer\MissingPropertiesResolver;
 use Rector\CodeQuality\NodeFactory\MissingPropertiesFactory;
 use Rector\NodeAnalyzer\ClassAnalyzer;
 use Rector\Php80\NodeAnalyzer\PhpAttributeAnalyzer;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -26,7 +26,7 @@ final class CompleteDynamicPropertiesRector extends AbstractRector
     public function __construct(
         private readonly MissingPropertiesFactory $missingPropertiesFactory,
         private readonly LocalPropertyAnalyzer $localPropertyAnalyzer,
-        private readonly ReflectionProvider $reflectionProvider,
+        private readonly ClassReflectionProvider $classReflectionProvider,
         private readonly ClassAnalyzer $classAnalyzer,
         private readonly PhpAttributeAnalyzer $phpAttributeAnalyzer,
         private readonly MissingPropertiesResolver $missingPropertiesResolver,
@@ -120,7 +120,7 @@ private function shouldSkipClass(Class_ $class): bool
         }
 
         $className = (string) $this->getName($class);
-        if (! $this->reflectionProvider->hasClass($className)) {
+        if (! $this->classReflectionProvider->hasClass($className)) {
             return true;
         }
 
@@ -129,7 +129,7 @@ private function shouldSkipClass(Class_ $class): bool
             return true;
         }
 
-        $classReflection = $this->reflectionProvider->getClass($className);
+        $classReflection = $this->classReflectionProvider->getClass($className);
 
         // properties are accessed via magic, nothing we can do
         if ($classReflection->hasMethod('__set')) {
@@ -140,7 +140,7 @@ private function shouldSkipClass(Class_ $class): bool
             return true;
         }
 
-        return $class->extends instanceof FullyQualified && ! $this->reflectionProvider->hasClass(
+        return $class->extends instanceof FullyQualified && ! $this->classReflectionProvider->hasClass(
             $class->extends->toString()
         );
     }
@@ -152,10 +152,10 @@ private function matchClassReflection(Class_ $class): ?ClassReflection
             return null;
         }
 
-        if (! $this->reflectionProvider->hasClass($className)) {
+        if (! $this->classReflectionProvider->hasClass($className)) {
             return null;
         }
 
-        return $this->reflectionProvider->getClass($className);
+        return $this->classReflectionProvider->getClass($className);
     }
 }

rules/CodeQuality/Rector/Isset_/IssetOnPropertyObjectToPropertyExistsRector.php

@@ -19,11 +19,11 @@
 use PhpParser\Node\Scalar\String_;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\Php\PhpPropertyReflection;
-use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\TypeCombinator;
 use Rector\PhpParser\Node\Value\ValueResolver;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Rector\Reflection\ReflectionResolver;
 use Rector\StaticTypeMapper\Resolver\ClassNameFromObjectTypeResolver;
 use Rector\ValueObject\MethodName;
@@ -36,7 +36,7 @@
 final class IssetOnPropertyObjectToPropertyExistsRector extends AbstractRector
 {
     public function __construct(
-        private readonly ReflectionProvider $reflectionProvider,
+        private readonly ClassReflectionProvider $classReflectionProvider,
         private readonly ReflectionResolver $reflectionResolver,
         private readonly ValueResolver $valueResolver
     ) {
@@ -217,10 +217,10 @@ private function matchPropertyTypeClassReflection(PropertyFetch $propertyFetch):
             return null;
         }
 
-        if (! $this->reflectionProvider->hasClass($className)) {
+        if (! $this->classReflectionProvider->hasClass($className)) {
             return null;
         }
 
-        return $this->reflectionProvider->getClass($className);
+        return $this->classReflectionProvider->getClass($className);
     }
 }

rules/CodeQuality/Rector/Property/FixClassCaseSensitivityVarDocblockRector.php

@@ -11,13 +11,13 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
 use Rector\Comments\NodeDocBlock\DocBlockUpdater;
 use Rector\Naming\Naming\UseImportsResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -29,7 +29,7 @@ final class FixClassCaseSensitivityVarDocblockRector extends AbstractRector
     public function __construct(
         private readonly PhpDocInfoFactory $phpDocInfoFactory,
         private readonly DocBlockUpdater $docBlockUpdater,
-        private readonly ReflectionProvider $reflectionProvider,
+        private readonly ClassReflectionProvider $classReflectionProvider,
         private readonly UseImportsResolver $useImportsResolver,
     ) {
     }
@@ -99,7 +99,7 @@ private function correctClassNameCasing(TypeNode $typeNode, Node $node): ?Identi
             return null;
         }
 
-        $realClassName = $this->reflectionProvider->getClass($existingClassName)
+        $realClassName = $this->classReflectionProvider->getClass($existingClassName)
             ->getName();
 
         $hasLeadingSlash = str_starts_with($writtenName, '\\');
@@ -131,7 +131,7 @@ private function resolveExistingClassName(string $writtenName, Node $node): ?str
 
         // already fully qualified
         if (str_starts_with($writtenName, '\\')) {
-            return $this->reflectionProvider->hasClass($bareName) ? $bareName : null;
+            return $this->classReflectionProvider->hasClass($bareName) ? $bareName : null;
         }
 
         $parts = explode('\\', $bareName);
@@ -155,7 +155,7 @@ private function resolveExistingClassName(string $writtenName, Node $node): ?str
                     $candidate .= '\\' . implode('\\', array_slice($parts, 1));
                 }
 
-                if ($this->reflectionProvider->hasClass($candidate)) {
+                if ($this->classReflectionProvider->hasClass($candidate)) {
                     return $candidate;
                 }
             }
@@ -165,13 +165,13 @@ private function resolveExistingClassName(string $writtenName, Node $node): ?str
         $scope = $node->getAttribute(AttributeKey::SCOPE);
         if ($scope instanceof Scope) {
             $namespace = $scope->getNamespace();
-            if ($namespace !== null && $this->reflectionProvider->hasClass($namespace . '\\' . $bareName)) {
+            if ($namespace !== null && $this->classReflectionProvider->hasClass($namespace . '\\' . $bareName)) {
                 return $namespace . '\\' . $bareName;
             }
         }
 
         // global namespace
-        if ($this->reflectionProvider->hasClass($bareName)) {
+        if ($this->classReflectionProvider->hasClass($bareName)) {
             return $bareName;
         }
 

rules/CodingStyle/Rector/String_/UseClassKeywordForClassNameResolutionRector.php

@@ -9,9 +9,9 @@
 use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Scalar\String_;
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Rector\AbstractRector;
+use Rector\Reflection\ClassReflectionProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -26,7 +26,7 @@ final class UseClassKeywordForClassNameResolutionRector extends AbstractRector
     private const string CLASS_BEFORE_STATIC_ACCESS_REGEX = '#(?<class_name>[\\\\a-zA-Z0-9_\\x80-\\xff]*)::#';
 
     public function __construct(
-        private readonly ReflectionProvider $reflectionProvider
+        private readonly ClassReflectionProvider $classReflectionProvider
     ) {
     }
 
@@ -111,7 +111,7 @@ private function getExistingClasses(String_ $string): array
         $classNames = [];
 
         foreach ($matches['class_name'] as $matchedClassName) {
-            if (! $this->reflectionProvider->hasClass($matchedClassName)) {
+            if (! $this->classReflectionProvider->hasClass($matchedClassName)) {
                 continue;
             }
 
@@ -129,7 +129,7 @@ private function createExpressionsToConcat(array $parts): array
     {
         $exprsToConcat = [];
         foreach ($parts as $part) {
-            if ($this->reflectionProvider->hasClass($part)) {
+            if ($this->classReflectionProvider->hasClass($part)) {
                 $exprsToConcat[] = new ClassConstFetch(new FullyQualified(ltrim($part, '\\')), 'class');
             } else {
                 $exprsToConcat[] = new String_($part);

rules/DeadCode/NodeManipulator/LivingCodeManipulator.php

@@ -30,16 +30,16 @@
 use PhpParser\Node\Expr\UnaryPlus;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Scalar;
-use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
 use Rector\NodeTypeResolver\NodeTypeResolver;
+use Rector\Reflection\ClassReflectionProvider;
 use Rector\ValueObject\MethodName;
 
 final readonly class LivingCodeManipulator
 {
     public function __construct(
         private NodeTypeResolver $nodeTypeResolver,
-        private ReflectionProvider $reflectionProvider
+        private ClassReflectionProvider $classReflectionProvider
     ) {
     }
 
@@ -122,11 +122,11 @@ private function hasCloneMagicMethod(Clone_ $clone): bool
         $cloneObjectType = $this->nodeTypeResolver->getType($clone->expr);
 
         foreach ($cloneObjectType->getObjectClassNames() as $className) {
-            if (! $this->reflectionProvider->hasClass($className)) {
+            if (! $this->classReflectionProvider->hasClass($className)) {
                 continue;
             }
 
-            if ($this->reflectionProvider->getClass($className)->hasNativeMethod(MethodName::CLONE)) {
+            if ($this->classReflectionProvider->getClass($className)->hasNativeMethod(MethodName::CLONE)) {
                 return true;
             }
         }

rules/DeadCode/Rector/StaticCall/RemoveParentCallWithoutParentRector.php

@@ -13,12 +13,12 @@
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Expression;
 use PHPStan\Reflection\ClassReflection;
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\Enum\ObjectReference;
 use Rector\NodeAnalyzer\ClassAnalyzer;
 use Rector\NodeManipulator\ClassMethodManipulator;
 use Rector\Rector\AbstractRector;
 use Rector\Reflection\ClassReflectionAnalyzer;
+use Rector\Reflection\ClassReflectionProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -30,7 +30,7 @@ final class RemoveParentCallWithoutParentRector extends AbstractRector
     public function __construct(
         private readonly ClassMethodManipulator $classMethodManipulator,
         private readonly ClassAnalyzer $classAnalyzer,
-        private readonly ReflectionProvider $reflectionProvider,
+        private readonly ClassReflectionProvider $classReflectionProvider,
         private readonly ClassReflectionAnalyzer $classReflectionAnalyzer
     ) {
     }
@@ -142,7 +142,7 @@ private function isParentStaticCall(Expr $expr): bool
     private function shouldSkipClass(Class_ $class): bool
     {
         // skip cases when parent class reflection is not found
-        if ($class->extends instanceof FullyQualified && ! $this->reflectionProvider->hasClass(
+        if ($class->extends instanceof FullyQualified && ! $this->classReflectionProvider->hasClass(
             $class->extends->toString()
         )) {
             return true;
@@ -180,11 +180,11 @@ private function hasUnresolvableAncestor(Name $parentName): bool
             return false;
         }
 
-        if (! $this->reflectionProvider->hasClass($parentClassName)) {
+        if (! $this->classReflectionProvider->hasClass($parentClassName)) {
             return true;
         }
 
-        $parentClassReflection = $this->reflectionProvider->getClass($parentClassName);
+        $parentClassReflection = $this->classReflectionProvider->getClass($parentClassName);
 
         return $this->hasUnresolvableParentClass($parentClassReflection);
     }

rules/Naming/Guard/HasMagicGetSetGuard.php

@@ -4,23 +4,23 @@
 
 namespace Rector\Naming\Guard;
 
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\Naming\ValueObject\PropertyRename;
+use Rector\Reflection\ClassReflectionProvider;
 
 final readonly class HasMagicGetSetGuard
 {
     public function __construct(
-        private ReflectionProvider $reflectionProvider
+        private ClassReflectionProvider $classReflectionProvider
     ) {
     }
 
     public function isConflicting(PropertyRename $propertyRename): bool
     {
-        if (! $this->reflectionProvider->hasClass($propertyRename->getClassLikeName())) {
+        if (! $this->classReflectionProvider->hasClass($propertyRename->getClassLikeName())) {
             return false;
         }
 
-        $classReflection = $this->reflectionProvider->getClass($propertyRename->getClassLikeName());
+        $classReflection = $this->classReflectionProvider->getClass($propertyRename->getClassLikeName());
         if ($classReflection->hasMethod('__set')) {
             return true;
         }