register node name resolvers

packages/NodeNameResolver/NodeNameResolver.php

@@ -19,6 +19,7 @@
 use Rector\NodeNameResolver\Contract\NodeNameResolverInterface;
 use Rector\NodeNameResolver\Regex\RegexPatternDetector;
 use Rector\NodeTypeResolver\Node\AttributeKey;
+use Webmozart\Assert\Assert;
 
 final class NodeNameResolver
 {
@@ -44,6 +45,7 @@ public function __construct(
         private readonly CallAnalyzer $callAnalyzer,
         private readonly iterable $nodeNameResolvers = []
     ) {
+        Assert::isNonEmptyList($nodeNameResolvers);
     }
 
     /**

src/DependencyInjection/LazyContainerFactory.php

@@ -10,25 +10,46 @@
 use PhpParser\Lexer;
 use PHPStan\Parser\Parser;
 use PHPStan\PhpDoc\TypeNodeResolver;
+use PHPStan\Reflection\ReflectionProvider;
 use Rector\BetterPhpDocParser\Contract\BasePhpDocNodeVisitorInterface;
 use Rector\BetterPhpDocParser\Contract\PhpDocParser\PhpDocNodeDecoratorInterface;
 use Rector\BetterPhpDocParser\PhpDocNodeMapper;
 use Rector\BetterPhpDocParser\PhpDocParser\BetterPhpDocParser;
 use Rector\Caching\Cache;
 use Rector\Caching\CacheFactory;
-use Rector\Core\Configuration\CurrentNodeProvider;
 use Rector\Core\Configuration\Option;
 use Rector\Core\Configuration\Parameter\SimpleParameterProvider;
-use Rector\NodeTypeResolver\DependencyInjection\PHPStanExtensionsConfigResolver;
+use Rector\NodeNameResolver\Contract\NodeNameResolverInterface;
+use Rector\NodeNameResolver\NodeNameResolver;
+use Rector\NodeTypeResolver\Contract\NodeTypeResolverInterface;
 use Rector\NodeTypeResolver\DependencyInjection\PHPStanServicesFactory;
+use Rector\NodeTypeResolver\NodeTypeResolver;
 use Rector\PHPStanStaticTypeMapper\Contract\TypeMapperInterface;
 use Rector\PHPStanStaticTypeMapper\PHPStanStaticTypeMapper;
 use Rector\StaticTypeMapper\Contract\PhpDocParser\PhpDocTypeMapperInterface;
+use Rector\StaticTypeMapper\Contract\PhpParser\PhpParserNodeMapperInterface;
 use Rector\StaticTypeMapper\Mapper\PhpParserNodeMapper;
 use Rector\StaticTypeMapper\PhpDoc\PhpDocTypeMapper;
 
 final class LazyContainerFactory
 {
+    /**
+     * @var array<class-string<NodeNameResolverInterface>>
+     */
+    private const NODE_NAME_RESOLVER_CLASSES = [
+        NodeNameResolver\ClassConstFetchNameResolver::class,
+        NodeNameResolver\ClassConstNameResolver::class,
+        NodeNameResolver\ClassNameResolver::class,
+        NodeNameResolver\EmptyNameResolver::class,
+        NodeNameResolver\FuncCallNameResolver::class,
+        NodeNameResolver\FunctionNameResolver::class,
+        NodeNameResolver\NameNameResolver::class,
+        NodeNameResolver\ParamNameResolver::class,
+        NodeNameResolver\PropertyNameResolver::class,
+        NodeNameResolver\UseNameResolver::class,
+        NodeNameResolver\VariableNameResolver::class,
+    ];
+
     /**
      * @api used as next container factory
      */
@@ -52,37 +73,50 @@ public function create(): Container
             return $cacheFactory->create();
         });
 
-        // php doc node parser
-        $container->singleton(BetterPhpDocParser::class, BetterPhpDocParser::class);
+        // tagged services
         $container->when(BetterPhpDocParser::class)
             ->needs('$phpDocNodeDecorators')
             ->giveTagged(PhpDocNodeDecoratorInterface::class);
 
-        $container->singleton(PHPStanStaticTypeMapper::class, PHPStanStaticTypeMapper::class);
         $container->when(PHPStanStaticTypeMapper::class)
             ->needs('$typeMappers')
             ->giveTagged(TypeMapperInterface::class);
 
-        $container->singleton(PhpDocTypeMapper::class, PhpDocTypeMapper::class);
         $container->when(PhpDocTypeMapper::class)
             ->needs('$phpDocTypeMappers')
             ->giveTagged(PhpDocTypeMapperInterface::class);
 
-        $container->singleton(PhpParserNodeMapper::class, PhpParserNodeMapper::class);
         $container->when(PhpParserNodeMapper::class)
             ->needs('$phpParserNodeMappers')
-            ->giveTagged(\Rector\StaticTypeMapper\Contract\PhpParser\PhpParserNodeMapperInterface::class);
+            ->giveTagged(PhpParserNodeMapperInterface::class);
+
+        $container->when(NodeTypeResolver::class)
+            ->needs('$nodeTypeResolvers')
+            ->giveTagged(NodeTypeResolverInterface::class);
+
+        // node name resolvers
+        $container->when(NodeNameResolver::class)
+            ->needs('$nodeNameResolvers')
+            ->giveTagged(NodeNameResolverInterface::class);
+
+        foreach (self::NODE_NAME_RESOLVER_CLASSES as $nodeNameResolverClass) {
+            $container->singleton($nodeNameResolverClass);
+            $container->tag($nodeNameResolverClass, NodeNameResolverInterface::class);
+        }
 
         $container->singleton(Parser::class, function (Container $container) {
             $phpstanServiceFactory = $container->make(PHPStanServicesFactory::class);
             return $phpstanServiceFactory->createPHPStanParser();
         });
 
         // phpstan factory
-        $container->singleton(CurrentNodeProvider::class, CurrentNodeProvider::class);
-
-        $container->singleton(PHPStanExtensionsConfigResolver::class, PHPStanExtensionsConfigResolver::class);
-        $container->singleton(PHPStanServicesFactory::class, PHPStanServicesFactory::class);
+        $container->singleton(
+            \PHPStan\Reflection\ReflectionProvider::class,
+            function (Container $container): ReflectionProvider {
+                $phpstanServiceFactory = $container->make(PHPStanServicesFactory::class);
+                return $phpstanServiceFactory->createReflectionProvider();
+            }
+        );
 
         $container->singleton(Parser::class, function (Container $container) {
             $phpstanServiceFactory = $container->make(PHPStanServicesFactory::class);

tests/PhpParser/Node/Value/ValueResolverTest.php

@@ -10,16 +10,15 @@
 use PhpParser\Node\Expr\BinaryOp\Plus;
 use PHPUnit\Framework\Attributes\DataProvider;
 use Rector\Core\PhpParser\Node\Value\ValueResolver;
-use Rector\Testing\PHPUnit\AbstractTestCase;
+use Rector\Testing\PHPUnit\AbstractLazyTestCase;
 
-final class ValueResolverTest extends AbstractTestCase
+final class ValueResolverTest extends AbstractLazyTestCase
 {
     private ValueResolver $valueResolver;
 
     protected function setUp(): void
     {
-        $this->boot();
-        $this->valueResolver = $this->getService(ValueResolver::class);
+        $this->valueResolver = $this->make(ValueResolver::class);
     }
 
     #[DataProvider('dataProvider')]
@@ -37,6 +36,7 @@ public static function dataProvider(): Iterator
         $builderFactory = new BuilderFactory();
 
         $classConstFetchNode = $builderFactory->classConstFetch('SomeClass', 'SOME_CONSTANT');
+
         yield [$classConstFetchNode, 'SomeClass::SOME_CONSTANT'];
         yield [$builderFactory->val(true), true];
         yield [$builderFactory->val(1), 1];