TemplateTypeCheck tries to resolve template type names such as self…

… because they're not usable

src/Rules/Generics/ClassTemplateTypeRule.php

@@ -41,6 +41,7 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		return $this->templateTypeCheck->check(
+			$scope,
 			$node,
 			TemplateTypeScope::createWithClass($className),
 			$classReflection->getTemplateTags(),

src/Rules/Generics/FunctionTemplateTypeRule.php

@@ -52,6 +52,7 @@ public function processNode(Node $node, Scope $scope): array
 		$escapedFunctionName = SprintfHelper::escapeFormatString($functionName);
 
 		return $this->templateTypeCheck->check(
+			$scope,
 			$node,
 			TemplateTypeScope::createWithFunction($functionName),
 			$resolvedPhpDoc->getTemplateTags(),

src/Rules/Generics/InterfaceTemplateTypeRule.php

@@ -38,6 +38,7 @@ public function processNode(Node $node, Scope $scope): array
 		$escapadInterfaceName = SprintfHelper::escapeFormatString($interfaceName);
 
 		return $this->templateTypeCheck->check(
+			$scope,
 			$node,
 			TemplateTypeScope::createWithClass($interfaceName),
 			$classReflection->getTemplateTags(),

src/Rules/Generics/MethodTemplateTypeRule.php

@@ -58,6 +58,7 @@ public function processNode(Node $node, Scope $scope): array
 		$escapedClassName = SprintfHelper::escapeFormatString($className);
 		$escapedMethodName = SprintfHelper::escapeFormatString($methodName);
 		$messages = $this->templateTypeCheck->check(
+			$scope,
 			$node,
 			TemplateTypeScope::createWithMethod($className, $methodName),
 			$methodTemplateTags,

src/Rules/Generics/TemplateTypeCheck.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Rules\Generics;
 
 use PhpParser\Node;
+use PHPStan\Analyser\Scope;
 use PHPStan\Internal\SprintfHelper;
 use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\Reflection\ReflectionProvider;
@@ -53,6 +54,7 @@ public function __construct(
 	 * @return RuleError[]
 	 */
 	public function check(
+		Scope $scope,
 		Node $node,
 		TemplateTypeScope $templateTypeScope,
 		array $templateTags,
@@ -64,7 +66,7 @@ public function check(
 	{
 		$messages = [];
 		foreach ($templateTags as $templateTag) {
-			$templateTagName = $templateTag->getName();
+			$templateTagName = $scope->resolveName(new Node\Name($templateTag->getName()));
 			if ($this->reflectionProvider->hasClass($templateTagName)) {
 				$messages[] = RuleErrorBuilder::message(sprintf(
 					$sameTemplateTypeNameAsClassMessage,

src/Rules/Generics/TraitTemplateTypeRule.php

@@ -52,6 +52,7 @@ public function processNode(Node $node, Scope $scope): array
 		$escapedTraitName = SprintfHelper::escapeFormatString($traitName);
 
 		return $this->templateTypeCheck->check(
+			$scope,
 			$node,
 			TemplateTypeScope::createWithClass($traitName),
 			$resolvedPhpDoc->getTemplateTags(),

tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php

@@ -5,6 +5,7 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use const PHP_VERSION_ID;
 
 /**
  * @extends RuleTestCase<ClassTemplateTypeRule>
@@ -119,4 +120,17 @@ public function testInInterface(): void
 		$this->analyse([__DIR__ . '/data/interface-template.php'], []);
 	}
 
+	public function testBug10049(): void
+	{
+		if (PHP_VERSION_ID < 80100) {
+			$this->markTestSkipped('Test requires PHP 8.1.');
+		}
+		$this->analyse([__DIR__ . '/data/bug-10049.php'], [
+			[
+				'PHPDoc tag @template for class Bug10049\SimpleEntity cannot have existing class Bug10049\SimpleEntity as its name.',
+				8,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Generics/data/bug-10049.php

@@ -0,0 +1,41 @@
+<?php // lint >= 8.1
+
+namespace Bug10049;
+
+/**
+ * @template SELF of SimpleEntity
+ */
+abstract class SimpleEntity
+{
+	/**
+	 * @param SimpleTable<SELF> $table
+	 */
+	public function __construct(protected readonly SimpleTable $table)
+	{
+	}
+}
+
+/**
+ * @template-covariant E of SimpleEntity
+ */
+class SimpleTable
+{
+	/**
+	 * @template ENTITY of SimpleEntity
+	 *
+	 * @param class-string<ENTITY> $className
+	 *
+	 * @return SimpleTable<ENTITY>
+	 */
+	public static function table(string $className, string $name): SimpleTable
+	{
+		return new SimpleTable($className, $name);
+	}
+
+	/**
+	 * @param class-string<E> $className
+	 */
+	private function __construct(readonly string $className, readonly string $table)
+	{
+	}
+}