Switch to typhoon/type v0.3

composer.json

@@ -15,8 +15,8 @@
         "nikic/php-parser": "^4.15",
         "phpstan/phpdoc-parser": "^1.0",
         "psr/simple-cache": "^3.0",
-        "typhoon/type": "^0.2@dev",
-        "typhoon/type-stringifier": "^0.2@dev"
+        "typhoon/type": "^0.3@dev",
+        "typhoon/type-stringifier": "^0.3@dev"
     },
     "require-dev": {
         "ergebnis/composer-normalize": "^2.41.1",

src/ClassReflection.php

@@ -6,8 +6,8 @@
 
 use Typhoon\Reflection\Reflector\ContextAwareReflection;
 use Typhoon\Reflection\Reflector\RootReflection;
-use Typhoon\Reflection\TypeResolver\ClassTemplateResolver;
 use Typhoon\Reflection\TypeResolver\StaticResolver;
+use Typhoon\Reflection\TypeResolver\TemplateResolver;
 use Typhoon\Type;
 
 /**
@@ -571,7 +571,7 @@ public function resolveTemplates(array $templateArguments = []): self
         }
 
         /** @var self<T> */
-        return $this->resolvedTypes(ClassTemplateResolver::create($this->name, $this->templates, $templateArguments));
+        return $this->resolvedTypes(TemplateResolver::create($this->templates, $templateArguments));
     }
 
     /**
@@ -668,7 +668,7 @@ protected function setContext(ReflectionContext $reflectionContext): void
         }
     }
 
-    private function resolvedTypes(ClassTemplateResolver|StaticResolver $typeResolver): self
+    private function resolvedTypes(TemplateResolver|StaticResolver $typeResolver): self
     {
         $class = clone $this;
         $class->propertiesIndexedByName = array_map(

src/MethodReflection.php

@@ -5,8 +5,8 @@
 namespace Typhoon\Reflection;
 
 use Typhoon\Reflection\Reflector\ContextAwareReflection;
-use Typhoon\Reflection\TypeResolver\ClassTemplateResolver;
 use Typhoon\Reflection\TypeResolver\StaticResolver;
+use Typhoon\Reflection\TypeResolver\TemplateResolver;
 
 /**
  * @api
@@ -411,7 +411,7 @@ public function getNativeReflection(): \ReflectionMethod
         return $this->nativeReflection ??= new \ReflectionMethod($this->class, $this->name);
     }
 
-    public function resolveTypes(ClassTemplateResolver|StaticResolver $typeResolver): self
+    public function resolveTypes(TemplateResolver|StaticResolver $typeResolver): self
     {
         $method = clone $this;
         $method->parameters = array_map(

src/NameResolution/NameAsClassResolver.php

@@ -28,12 +28,7 @@ public function constant(string $name): mixed
         throw new ReflectionException(sprintf('Name "%s" cannot be resolved as class.', $name));
     }
 
-    public function classTemplate(string $class, string $name): mixed
-    {
-        throw new ReflectionException(sprintf('Name "%s" cannot be resolved as class.', $class));
-    }
-
-    public function methodTemplate(string $class, string $method, string $name): mixed
+    public function template(string $name): mixed
     {
         throw new ReflectionException(sprintf('Name "%s" cannot be resolved as class.', $name));
     }

src/NameResolution/NameAsTypeResolver.php

@@ -31,22 +31,17 @@ public function class(string $name): mixed
 
     public function static(string $self): mixed
     {
-        return types::static($self, ...$this->templateArguments);
+        return types::static(...$this->templateArguments);
     }
 
     public function constant(string $name): mixed
     {
         return types::constant($name);
     }
 
-    public function classTemplate(string $class, string $name): mixed
+    public function template(string $name): mixed
     {
-        return types::classTemplate($class, $name);
-    }
-
-    public function methodTemplate(string $class, string $method, string $name): mixed
-    {
-        return types::methodTemplate($class, $method, $name);
+        return types::template($name);
     }
 
     public function classOrConstants(string $classCandidate, array $constantCandidates): mixed

src/NameResolution/NameContext.php

@@ -35,8 +35,6 @@ final class NameContext
      */
     private array $classTemplateNamesMap = [];
 
-    private ?UnqualifiedName $method = null;
-
     /**
      * @var array<non-empty-string, true>
      */
@@ -107,11 +105,10 @@ public function enterClass(string $name, ?string $parent = null, array $template
     /**
      * @param array<string> $templateNames
      */
-    public function enterMethod(string $name, array $templateNames = []): void
+    public function enterMethod(array $templateNames = []): void
     {
         $this->leaveMethod();
 
-        $this->method = new UnqualifiedName($name);
         $this->methodTemplateNamesMap = array_fill_keys(
             array_map(
                 /** @return non-empty-string */
@@ -124,7 +121,6 @@ public function enterMethod(string $name, array $templateNames = []): void
 
     public function leaveMethod(): void
     {
-        $this->method = null;
         $this->methodTemplateNamesMap = [];
     }
 
@@ -223,12 +219,12 @@ public function resolveName(string|Name $name, NameResolver $resolver): mixed
                 return $resolver->static($this->resolveNameAsClass($this->self));
             }
 
-            if ($this->method !== null && isset($this->methodTemplateNamesMap[$nameAsString])) {
-                return $resolver->methodTemplate($this->resolveNameAsClass($this->self), $this->method->toString(), $nameAsString);
+            if (isset($this->methodTemplateNamesMap[$nameAsString])) {
+                return $resolver->template($nameAsString);
             }
 
             if (isset($this->classTemplateNamesMap[$nameAsString])) {
-                return $resolver->classTemplate($this->resolveNameAsClass($this->self), $nameAsString);
+                return $resolver->template($nameAsString);
             }
         }
 

src/NameResolution/NameResolver.php

@@ -30,19 +30,10 @@ public function static(string $self): mixed;
     public function constant(string $name): mixed;
 
     /**
-     * @param class-string $class
      * @param non-empty-string $name
      * @return T
      */
-    public function classTemplate(string $class, string $name): mixed;
-
-    /**
-     * @param class-string $class
-     * @param non-empty-string $method
-     * @param non-empty-string $name
-     * @return T
-     */
-    public function methodTemplate(string $class, string $method, string $name): mixed;
+    public function template(string $name): mixed;
 
     /**
      * @param non-empty-string $classCandidate

src/ParameterReflection.php

@@ -5,8 +5,8 @@
 namespace Typhoon\Reflection;
 
 use Typhoon\Reflection\Reflector\ContextAwareReflection;
-use Typhoon\Reflection\TypeResolver\ClassTemplateResolver;
 use Typhoon\Reflection\TypeResolver\StaticResolver;
+use Typhoon\Reflection\TypeResolver\TemplateResolver;
 
 /**
  * @api
@@ -176,7 +176,7 @@ public function getNativeReflection(): \ReflectionParameter
         );
     }
 
-    public function resolveTypes(ClassTemplateResolver|StaticResolver $typeResolver): self
+    public function resolveTypes(TemplateResolver|StaticResolver $typeResolver): self
     {
         $parameter = clone $this;
         $parameter->type = $this->type->resolve($typeResolver);

src/PropertyReflection.php

@@ -5,8 +5,8 @@
 namespace Typhoon\Reflection;
 
 use Typhoon\Reflection\Reflector\ContextAwareReflection;
-use Typhoon\Reflection\TypeResolver\ClassTemplateResolver;
 use Typhoon\Reflection\TypeResolver\StaticResolver;
+use Typhoon\Reflection\TypeResolver\TemplateResolver;
 
 /**
  * @api
@@ -203,7 +203,7 @@ public function getNativeReflection(): \ReflectionProperty
         return $this->nativeReflection ??= new \ReflectionProperty($this->class, $this->name);
     }
 
-    public function resolveTypes(ClassTemplateResolver|StaticResolver $typeResolver): self
+    public function resolveTypes(TemplateResolver|StaticResolver $typeResolver): self
     {
         $property = clone $this;
         $property->type = $this->type->resolve($typeResolver);

src/Reflector/NameContextVisitor.php

@@ -67,10 +67,7 @@ public function enterNode(Node $node): ?int
         }
 
         if ($node instanceof Stmt\ClassMethod) {
-            $this->nameContext->enterMethod(
-                name: $node->name->name,
-                templateNames: PhpDocParsingVisitor::fromNode($node)->templateNames(),
-            );
+            $this->nameContext->enterMethod(PhpDocParsingVisitor::fromNode($node)->templateNames());
 
             return null;
         }

src/Reflector/NativeReflectionReflector.php

@@ -280,7 +280,7 @@ private function reflectNativeType(?\ReflectionType $reflectionType, ?string $cl
                 throw new \LogicException('Cannot use type "static" outside of class scope.');
             }
 
-            return types::static($class);
+            return types::static();
         }
 
         $type = match ($name) {

src/Reflector/PhpDocTypeReflector.php

@@ -274,12 +274,12 @@ private function reflectIterable(array $templateArguments): Type\Type
         };
     }
 
-    private function reflectArrayShape(ArrayShapeNode $node): Type\ShapeType
+    private function reflectArrayShape(ArrayShapeNode $node): Type\ArrayShapeType
     {
         $elements = [];
 
         foreach ($node->items as $item) {
-            $type = types::element($this->doReflect($item->valueType), $item->optional);
+            $type = types::arrayElement($this->doReflect($item->valueType), $item->optional);
 
             if ($item->keyName === null) {
                 $elements[] = $type;
@@ -299,7 +299,7 @@ private function reflectArrayShape(ArrayShapeNode $node): Type\ShapeType
             $elements[$key] = $type;
         }
 
-        return types::shape($elements, $node->sealed);
+        return types::arrayShape($elements, $node->sealed);
     }
 
     private function reflectConstExpr(ConstTypeNode $node): Type\Type

src/Reflector/PhpParserReflector.php

@@ -333,7 +333,7 @@ private function reflectOwnMethods(string $class, Stmt\ClassLike $classNode): ar
             $phpDoc = PhpDocParsingVisitor::fromNode($node);
 
             try {
-                $this->nameContext->enterMethod($name, $phpDoc->templateNames());
+                $this->nameContext->enterMethod($phpDoc->templateNames());
 
                 $methods[] = new MethodReflection(
                     class: $class,
@@ -534,13 +534,11 @@ private function reflectNativeType(?Node $node): ?Type\Type
         }
 
         if ($node instanceof Name) {
-            $resolvedName = $this->nameContext->resolveNameAsClass($node->toCodeString());
-
             if ($node->toString() === 'static') {
-                return types::static($resolvedName);
+                return types::static();
             }
 
-            return types::object($resolvedName);
+            return types::object($this->nameContext->resolveNameAsClass($node->toCodeString()));
         }
 
         throw new ReflectionException(sprintf('%s is not supported.', $node::class));

src/TypeReflection.php

@@ -4,8 +4,8 @@
 
 namespace Typhoon\Reflection;
 
-use Typhoon\Reflection\TypeResolver\ClassTemplateResolver;
 use Typhoon\Reflection\TypeResolver\StaticResolver;
+use Typhoon\Reflection\TypeResolver\TemplateResolver;
 use Typhoon\Type\Type;
 use Typhoon\Type\types;
 
@@ -69,7 +69,7 @@ public function getResolved(): Type
         return $this->resolved;
     }
 
-    public function resolve(ClassTemplateResolver|StaticResolver $typeResolver): self
+    public function resolve(TemplateResolver|StaticResolver $typeResolver): self
     {
         return new self(
             native: $this->native,