[PropertyInfo] Replace NameScope by TypeContext

Author: mtarld

src/Symfony/Component/PropertyInfo/Extractor/PhpStanExtractor.php

@@ -24,14 +24,13 @@
 use PHPStan\PhpDocParser\Parser\TokenIterator;
 use PHPStan\PhpDocParser\Parser\TypeParser;
 use PHPStan\PhpDocParser\ParserConfig;
-use Symfony\Component\PropertyInfo\PhpStan\NameScope;
-use Symfony\Component\PropertyInfo\PhpStan\NameScopeFactory;
 use Symfony\Component\PropertyInfo\PropertyDescriptionExtractorInterface;
 use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
 use Symfony\Component\PropertyInfo\Type as LegacyType;
 use Symfony\Component\PropertyInfo\Util\PhpStanTypeHelper;
 use Symfony\Component\TypeInfo\Exception\UnsupportedException;
 use Symfony\Component\TypeInfo\Type;
+use Symfony\Component\TypeInfo\TypeContext\TypeContext;
 use Symfony\Component\TypeInfo\TypeContext\TypeContextFactory;
 use Symfony\Component\TypeInfo\TypeResolver\StringTypeResolver;
 
@@ -48,7 +47,6 @@ final class PhpStanExtractor implements PropertyDescriptionExtractorInterface, P
 
     private PhpDocParser $phpDocParser;
     private Lexer $lexer;
-    private NameScopeFactory $nameScopeFactory;
 
     private StringTypeResolver $stringTypeResolver;
     private TypeContextFactory $typeContextFactory;
@@ -60,7 +58,7 @@ final class PhpStanExtractor implements PropertyDescriptionExtractorInterface, P
     private array $accessorPrefixes;
     private array $arrayMutatorPrefixes;
 
-    /** @var array<string, NameScope> */
+    /** @var array<string, TypeContext> */
     private array $contexts = [];
 
     /**
@@ -91,7 +89,6 @@ public function __construct(?array $mutatorPrefixes = null, ?array $accessorPref
             $this->phpDocParser = new PhpDocParser(new TypeParser(new ConstExprParser()), new ConstExprParser());
             $this->lexer = new Lexer();
         }
-        $this->nameScopeFactory = new NameScopeFactory();
         $this->stringTypeResolver = new StringTypeResolver();
         $this->typeContextFactory = new TypeContextFactory($this->stringTypeResolver);
     }
@@ -133,8 +130,9 @@ public function getTypes(string $class, string $property, array $context = []):
                 continue;
             }
 
-            $nameScope ??= $this->contexts[$class.'/'.$declaringClass] ??= $this->nameScopeFactory->create($class, $declaringClass);
-            foreach ($this->phpStanTypeHelper->getTypes($tagDocNode->value, $nameScope) as $type) {
+            $typeContext = $this->contexts[$class.'/'.$declaringClass] ??= $this->typeContextFactory->createFromClassName($class, $declaringClass);
+
+            foreach ($this->phpStanTypeHelper->getTypes($tagDocNode->value, $typeContext) as $type) {
                 switch ($type->getClassName()) {
                     case 'self':
                     case 'static':
@@ -177,7 +175,7 @@ public function getTypesFromConstructor(string $class, string $property): ?array
         }
 
         $types = [];
-        foreach ($this->phpStanTypeHelper->getTypes($tagDocNode, $this->nameScopeFactory->create($class)) as $type) {
+        foreach ($this->phpStanTypeHelper->getTypes($tagDocNode, $this->typeContextFactory->createFromClassName($class)) as $type) {
             $types[] = $type;
         }
 

src/Symfony/Component/PropertyInfo/PhpStan/NameScope.php

@@ -26,8 +26,8 @@
 use PHPStan\PhpDocParser\Ast\Type\ThisTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
-use Symfony\Component\PropertyInfo\PhpStan\NameScope;
 use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\TypeInfo\TypeContext\TypeContext;
 
 /**
  * Transforms a php doc tag value to a {@link Type} instance.
@@ -43,10 +43,10 @@ final class PhpStanTypeHelper
      *
      * @return Type[]
      */
-    public function getTypes(PhpDocTagValueNode $node, NameScope $nameScope): array
+    public function getTypes(PhpDocTagValueNode $node, TypeContext $typeContext): array
     {
         if ($node instanceof ParamTagValueNode || $node instanceof ReturnTagValueNode || $node instanceof VarTagValueNode) {
-            return $this->compressNullableType($this->extractTypes($node->type, $nameScope));
+            return $this->compressNullableType($this->extractTypes($node->type, $typeContext));
         }
 
         return [];
@@ -98,7 +98,7 @@ private function compressNullableType(array $types): array
     /**
      * @return Type[]
      */
-    private function extractTypes(TypeNode $node, NameScope $nameScope): array
+    private function extractTypes(TypeNode $node, TypeContext $typeContext): array
     {
         if ($node instanceof UnionTypeNode) {
             $types = [];
@@ -107,7 +107,7 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
                     // It's safer to fall back to other extractors here, as resolving const types correctly is not easy at the moment
                     return [];
                 }
-                foreach ($this->extractTypes($type, $nameScope) as $subType) {
+                foreach ($this->extractTypes($type, $typeContext) as $subType) {
                     $types[] = $subType;
                 }
             }
@@ -119,7 +119,7 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
                 return [new Type(Type::BUILTIN_TYPE_STRING)];
             }
 
-            [$mainType] = $this->extractTypes($node->type, $nameScope);
+            [$mainType] = $this->extractTypes($node->type, $typeContext);
 
             if (Type::BUILTIN_TYPE_INT === $mainType->getBuiltinType()) {
                 return [$mainType];
@@ -135,14 +135,14 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
             $collectionKeyTypes = $mainType->getCollectionKeyTypes();
             $collectionKeyValues = [];
             if (1 === \count($node->genericTypes)) {
-                foreach ($this->extractTypes($node->genericTypes[0], $nameScope) as $subType) {
+                foreach ($this->extractTypes($node->genericTypes[0], $typeContext) as $subType) {
                     $collectionKeyValues[] = $subType;
                 }
             } elseif (2 === \count($node->genericTypes)) {
-                foreach ($this->extractTypes($node->genericTypes[0], $nameScope) as $keySubType) {
+                foreach ($this->extractTypes($node->genericTypes[0], $typeContext) as $keySubType) {
                     $collectionKeyTypes[] = $keySubType;
                 }
-                foreach ($this->extractTypes($node->genericTypes[1], $nameScope) as $valueSubType) {
+                foreach ($this->extractTypes($node->genericTypes[1], $typeContext) as $valueSubType) {
                     $collectionKeyValues[] = $valueSubType;
                 }
             }
@@ -153,13 +153,13 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
             return [new Type(Type::BUILTIN_TYPE_ARRAY, false, null, true)];
         }
         if ($node instanceof ArrayTypeNode) {
-            return [new Type(Type::BUILTIN_TYPE_ARRAY, false, null, true, [new Type(Type::BUILTIN_TYPE_INT)], $this->extractTypes($node->type, $nameScope))];
+            return [new Type(Type::BUILTIN_TYPE_ARRAY, false, null, true, [new Type(Type::BUILTIN_TYPE_INT)], $this->extractTypes($node->type, $typeContext))];
         }
         if ($node instanceof CallableTypeNode || $node instanceof CallableTypeParameterNode) {
             return [new Type(Type::BUILTIN_TYPE_CALLABLE)];
         }
         if ($node instanceof NullableTypeNode) {
-            $subTypes = $this->extractTypes($node->type, $nameScope);
+            $subTypes = $this->extractTypes($node->type, $typeContext);
             if (\count($subTypes) > 1) {
                 $subTypes[] = new Type(Type::BUILTIN_TYPE_NULL);
 
@@ -169,7 +169,7 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
             return [new Type($subTypes[0]->getBuiltinType(), true, $subTypes[0]->getClassName(), $subTypes[0]->isCollection(), $subTypes[0]->getCollectionKeyTypes(), $subTypes[0]->getCollectionValueTypes())];
         }
         if ($node instanceof ThisTypeNode) {
-            return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $nameScope->resolveRootClass())];
+            return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $typeContext->getCalledClass())];
         }
         if ($node instanceof IdentifierTypeNode) {
             if (\in_array($node->name, Type::$builtinTypes, true)) {
@@ -190,7 +190,7 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
                 'mixed' => [], // mixed seems to be ignored in all other extractors
                 'parent' => [new Type(Type::BUILTIN_TYPE_OBJECT, false, $node->name)],
                 'static',
-                'self' => [new Type(Type::BUILTIN_TYPE_OBJECT, false, $nameScope->resolveRootClass())],
+                'self' => [new Type(Type::BUILTIN_TYPE_OBJECT, false, $typeContext->getCalledClass())],
                 'class-string',
                 'html-escaped-string',
                 'lowercase-string',
@@ -205,7 +205,7 @@ private function extractTypes(TypeNode $node, NameScope $nameScope): array
                 'number' => [new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_FLOAT)],
                 'numeric' => [new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_FLOAT), new Type(Type::BUILTIN_TYPE_STRING)],
                 'array-key' => [new Type(Type::BUILTIN_TYPE_STRING), new Type(Type::BUILTIN_TYPE_INT)],
-                default => [new Type(Type::BUILTIN_TYPE_OBJECT, false, $nameScope->resolveStringName($node->name))],
+                default => [new Type(Type::BUILTIN_TYPE_OBJECT, false, $typeContext->normalize($node->name))],
             };
         }