Resolve generic parameter defaults that reference other template parameters

When a template parameter has a default referencing another template
parameter (e.g. `@template DO of EI = EI`), the default was left as
an unresolved TemplateType instead of being substituted with the
concrete type provided for the referenced parameter.

The root cause is that resolveTemplateTypes returns resolved values
without re-invoking the callback, so transitive TemplateType
references in the standins map are never resolved.

Fixed in ClassReflection::typeMapFromList — the single gateway where
all type arguments enter the standins map. After building the map,
any entry that is a TemplateType referencing another entry in the
same class is resolved to that entry's concrete type.

Co-Authored-By: Claude Code

Author: JanTvrdik

src/Reflection/ClassReflection.php

@@ -40,6 +40,7 @@
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\Generic\TemplateType;
 use PHPStan\Type\Generic\TemplateTypeFactory;
 use PHPStan\Type\Generic\TemplateTypeHelper;
 use PHPStan\Type\Generic\TemplateTypeMap;
@@ -1741,6 +1742,18 @@ public function typeMapFromList(array $types): TemplateTypeMap
 			$i++;
 		}
 
+		$className = $this->getName();
+		foreach ($map as $name => $type) {
+			if (!$type instanceof TemplateType || $type->getScope()->getClassName() !== $className) {
+				continue;
+			}
+			$resolved = $map[$type->getName()] ?? null;
+			if ($resolved === null || $resolved instanceof TemplateType) {
+				continue;
+			}
+			$map[$name] = $resolved;
+		}
+
 		return new TemplateTypeMap($map);
 	}
 

tests/PHPStan/Analyser/nsrt/template-default-referring-other.php

@@ -0,0 +1,117 @@
+<?php // lint >= 8.1
+
+namespace TemplateDefaultReferringOther;
+
+use function PHPStan\Testing\assertType;
+
+class MoneyValue
+{
+
+    public function __construct(
+        public readonly string $currency,
+        public readonly int $cents,
+    )
+    {
+    }
+
+}
+
+/**
+ * @template-contravariant DI
+ * @template-contravariant EI
+ * @template-covariant DO of EI = EI
+ * @template-covariant EO of DI = DI
+ */
+interface Codec
+{
+
+    /**
+     * @param DI $data
+     * @return DO
+     */
+    public function decode(mixed $data): mixed;
+
+    /**
+     * @param EI $data
+     * @return EO
+     */
+    public function encode(mixed $data): mixed;
+
+}
+
+/**
+ * @implements Codec<
+ *   array{currency: string, cents: int},
+ *   MoneyValue,
+ * >
+ */
+class MoneyCodec implements Codec
+{
+
+    public function decode(mixed $data): MoneyValue
+    {
+        return new MoneyValue($data['currency'], $data['cents']);
+    }
+
+    public function encode(mixed $data): array
+    {
+        return [
+            'currency' => $data->currency,
+            'cents' => $data->cents,
+        ];
+    }
+
+}
+
+/**
+ * @implements Codec<
+ *   string,
+ *   \DateTimeInterface,
+ *   \DateTimeImmutable,
+ *   string,
+ * >
+ */
+class DateTimeInterfaceCodec implements Codec
+{
+
+    public function decode(mixed $data): \DateTimeImmutable
+    {
+       return new \DateTimeImmutable($data);
+    }
+
+    public function encode(mixed $data): string
+    {
+        return $data->format('c');
+    }
+
+}
+
+/**
+ * @param Codec<array{currency: string, cents: int}, MoneyValue> $moneyCodec
+ * @param Codec<string, \DateTimeInterface, \DateTimeImmutable, string> $dtCodec
+ */
+function test(
+    Codec $moneyCodec,
+    Codec $dtCodec,
+    string $dtString,
+    \DateTimeInterface $dtInterface,
+): void
+{
+    assertType('TemplateDefaultReferringOther\MoneyValue', $moneyCodec->decode(['currency' => 'CZK', 'cents' => 123]));
+    assertType('array{currency: string, cents: int}', $moneyCodec->encode(new MoneyValue('CZK', 100)));
+
+    assertType('DateTimeImmutable', $dtCodec->decode($dtString));
+    assertType('string', $dtCodec->encode($dtInterface));
+}
+
+function testMoneyCodecDirect(MoneyCodec $codec): void
+{
+    assertType('TemplateDefaultReferringOther\MoneyValue', $codec->decode(['currency' => 'CZK', 'cents' => 123]));
+    assertType('array{currency: string, cents: int}', $codec->encode(new MoneyValue('CZK', 100)));
+}
+
+function testDateTimeCodecDirect(DateTimeInterfaceCodec $codec): void
+{
+    assertType('DateTimeImmutable', $codec->decode('2024-01-01'));
+    assertType('string', $codec->encode(new \DateTimeImmutable()));
+}