Add resolution of generic @method tags

src/PhpDoc/PhpDocNodeResolver.php

@@ -30,6 +30,9 @@
 use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
 use PHPStan\Reflection\PassedByReference;
 use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
+use PHPStan\Type\Generic\TemplateTypeFactory;
+use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\Generic\TemplateTypeScope;
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
@@ -160,12 +163,30 @@
 
 		foreach (['@method', '@psalm-method', '@phpstan-method'] as $tagName) {
 			foreach ($phpDocNode->getMethodTagValues($tagName) as $tagValue) {
+				$templateTags = [];
+
+				if (count($tagValue->templateTypes) > 0) {
+					foreach ($tagValue->templateTypes as $templateType) {
+						$templateTags[$templateType->name] = new TemplateTag(
+							$templateType->name,
+							$templateType->bound !== null
+								? $this->typeNodeResolver->resolve($templateType->bound, $nameScope)
+								: new MixedType(),
+							TemplateTypeVariance::createInvariant()
+						);
+					}
+
+					$templateTypeScope = TemplateTypeScope::createWithMethod($nameScope->getClassName(), $tagValue->methodName);
+					$templateTypeMap = new TemplateTypeMap(array_map(static fn (TemplateTag $tag): Type => TemplateTypeFactory::fromTemplateTag($templateTypeScope, $tag), $templateTags));
+					$nameScope = $nameScope->withTemplateTypeMap($templateTypeMap);
+				}
+
 				$parameters = [];
 				foreach ($tagValue->parameters as $parameterNode) {
 					$parameterName = substr($parameterNode->parameterName, 1);
 					$type = $parameterNode->type !== null
 						? $this->typeNodeResolver->resolve($parameterNode->type, $nameScope)
 						: new MixedType();
 					if ($parameterNode->defaultValue instanceof ConstExprNullNode) {
 						$type = TypeCombinator::addNull($type);
 					}
@@ -191,6 +212,7 @@
 						: new MixedType(),
 					$tagValue->isStatic,
 					$parameters,
+					$templateTags,
 				);
 			}
 		}

src/PhpDoc/Tag/MethodTag.php

@@ -10,11 +10,13 @@ class MethodTag
 
 	/**
 	 * @param array<string, MethodTagParameter> $parameters
+	 * @param array<string, TemplateTag> $templateTags
 	 */
 	public function __construct(
 		private Type $returnType,
 		private bool $isStatic,
 		private array $parameters,
+		private array $templateTags = [],
 	)
 	{
 	}
@@ -37,4 +39,12 @@ public function getParameters(): array
 		return $this->parameters;
 	}
 
+	/**
+	 * @return array<string, TemplateTag>
+	 */
+	public function getTemplateTags(): array
+	{
+		return $this->templateTags;
+	}
+
 }

src/Reflection/Annotations/AnnotationMethodReflection.php

@@ -30,6 +30,7 @@ public function __construct(
 		private bool $isStatic,
 		private bool $isVariadic,
 		private ?Type $throwType,
+		private TemplateTypeMap $templateTypeMap,
 	)
 	{
 	}
@@ -69,7 +70,7 @@ public function getVariants(): array
 		if ($this->variants === null) {
 			$this->variants = [
 				new FunctionVariantWithPhpDocs(
-					TemplateTypeMap::createEmpty(),
+					$this->templateTypeMap,
 					null,
 					$this->parameters,
 					$this->isVariadic,

src/Reflection/Annotations/AnnotationsMethodsClassReflectionExtension.php

@@ -2,12 +2,18 @@
 
 namespace PHPStan\Reflection\Annotations;
 
+use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ExtendedMethodReflection;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\MethodsClassReflectionExtension;
+use PHPStan\Type\Generic\TemplateTypeFactory;
 use PHPStan\Type\Generic\TemplateTypeHelper;
+use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\Generic\TemplateTypeScope;
 use PHPStan\Type\Generic\TemplateTypeVariance;
+use PHPStan\Type\Type;
+
 use function count;
 
 class AnnotationsMethodsClassReflectionExtension implements MethodsClassReflectionExtension
@@ -57,6 +63,13 @@ private function findClassReflectionWithMethod(
 				);
 			}
 
+			$templateTypeScope = TemplateTypeScope::createWithClass($classReflection->getName());
+
+			$templateTypeMap = new TemplateTypeMap(array_map(
+				static fn (TemplateTag $tag): Type => TemplateTypeFactory::fromTemplateTag($templateTypeScope, $tag),
+				$methodTags[$methodName]->getTemplateTags()
+			));
+
 			$isStatic = $methodTags[$methodName]->isStatic();
 			$nativeCallMethodName = $isStatic ? '__callStatic' : '__call';
 
@@ -75,6 +88,7 @@ private function findClassReflectionWithMethod(
 				$classReflection->hasNativeMethod($nativeCallMethodName)
 					? $classReflection->getNativeMethod($nativeCallMethodName)->getThrowType()
 					: null,
+				$templateTypeMap,
 			);
 		}
 

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -22,6 +22,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/json-decode/narrow_type_with_force_array.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/json-decode/invalid_type.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/json-decode/json_object_as_array.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/generic-method-tags.php');
 
 		require_once __DIR__ . '/data/bug2574.php';
 

tests/PHPStan/Analyser/data/generic-method-tags.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace GenericMethodTags;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @method TVal doThing<TVal of mixed>(TVal $param)
+ */
+class Test
+{
+	public function __call(): mixed
+	{
+	}
+}
+
+function test(int $int, string $string): void
+{
+	$test = new Test();
+
+	assertType('int', $test->doThing($int));
+	assertType('string', $test->doThing($string));
+}