feat: Support for @template default types

src/NativePHPDoc/Definition/NativePHPDoc/NativePHPDocDefinitionProvider.php

@@ -315,7 +315,13 @@ function () use ($node, $value, $temporaryContext) {
 							Str::endsWith($node->name, '-covariant')     => TemplateTypeVariance::COVARIANT,
 							Str::endsWith($node->name, '-contravariant') => TemplateTypeVariance::CONTRAVARIANT,
 							default                                      => TemplateTypeVariance::INVARIANT
-						}
+						},
+						default: $value->default ?
+							$this->phpDocTypeMapper->map(
+								$value->default,
+								$temporaryContext->value(),
+							) :
+							null,
 					);
 				}
 			);

src/NativePHPDoc/Definition/TypeDefinition/TypeParameterDefinition.php

@@ -16,6 +16,7 @@ public function __construct(
 		public readonly bool $variadic,
 		public readonly ?Type $upperBound,
 		public readonly TemplateTypeVariance $variance,
+		public readonly ?Type $default = null,
 	) {}
 
 	public function __toString(): string
@@ -28,6 +29,7 @@ public function __toString(): string
 			},
 			($this->variadic ? '...' : '') . $this->name,
 			$this->upperBound ? "of {$this->upperBound}" : '',
+			$this->default ? "= {$this->default}" : '',
 		];
 
 		return implode(' ', array_filter($result));

src/Type/Template/TypeParameterMap.php

@@ -23,7 +23,7 @@ public function __construct(
 	 */
 	public static function fromArguments(array $arguments, iterable $typeParameters): self
 	{
-		if (!$arguments) {
+		if (!$typeParameters) {
 			return self::empty();
 		}
 
@@ -37,8 +37,10 @@ public static function fromArguments(array $arguments, iterable $typeParameters)
 				break;
 			}
 
-			if (!$argument = $arguments[$i] ?? null) {
-				break;
+			$argument = $arguments[$i] ?? $parameter->default;
+
+			if (!$argument) {
+				continue;
 			}
 
 			$map[$parameter->name] = $argument;

tests/Integration/Reflection/ReflectionSnapshots/Tests.Stubs.Classes.DoubleTemplateType.yaml

@@ -1,4 +1,4 @@
-type: Tests\Stubs\Classes\DoubleTemplateType
+type: Tests\Stubs\Classes\DoubleTemplateType<int>
 qualifiedName: Tests\Stubs\Classes\DoubleTemplateType
 shortName: DoubleTemplateType
 location: Tests\Stubs\Classes\DoubleTemplateType
@@ -22,13 +22,35 @@ typeParameters:
         variadic: false
         upperBound: mixed
         variance: INVARIANT
-        asString: TTwo
+        asString: 'TTwo = int'
 extends: null
 implements: {  }
 uses:
     traits: {  }
     excludedTraitMethods: {  }
 declaredProperties: {  }
 properties: {  }
-declaredMethods: {  }
-methods: {  }
+declaredMethods:
+    -
+        asString: something()
+        name: something
+        location: 'Tests\Stubs\Classes\DoubleTemplateType::something()'
+        declaringType: Tests\Stubs\Classes\DoubleTemplateType<int>
+        attributes:
+            asString: '#[]'
+            all: {  }
+        typeParameters: {  }
+        parameters: {  }
+        returnType: int
+methods:
+    -
+        asString: something()
+        name: something
+        location: 'Tests\Stubs\Classes\DoubleTemplateType::something()'
+        declaringType: Tests\Stubs\Classes\DoubleTemplateType<int>
+        attributes:
+            asString: '#[]'
+            all: {  }
+        typeParameters: {  }
+        parameters: {  }
+        returnType: int

tests/Stubs/Classes/DoubleTemplateType.php

@@ -4,8 +4,12 @@
 
 /**
  * @template TOne
- * @template TTwo
+ * @template TTwo = int
  */
 class DoubleTemplateType
 {
+	/**
+	 * @return TTwo
+	 */
+	public function something(): mixed {}
 }

tests/Unit/Type/Definition/TypeDefinition/TypeParameterDefinitionTest.php

@@ -4,6 +4,7 @@
 
 use GoodPhp\Reflection\NativePHPDoc\Definition\TypeDefinition\TypeParameterDefinition;
 use GoodPhp\Reflection\Type\PrimitiveType;
+use GoodPhp\Reflection\Type\Special\MixedType;
 use GoodPhp\Reflection\Type\Template\TemplateTypeVariance;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -93,5 +94,16 @@ public static function toStringProvider(): iterable
 				variance: TemplateTypeVariance::COVARIANT,
 			),
 		];
+
+		yield [
+			'covariant T of mixed = int',
+			new TypeParameterDefinition(
+				name: 'T',
+				variadic: false,
+				upperBound: MixedType::get(),
+				variance: TemplateTypeVariance::COVARIANT,
+				default: PrimitiveType::integer(),
+			),
+		];
 	}
 }