Enhance type handling and testing across various components; introduce BaseGenericFactory and BaseGenericMap for improved generic handling; add comprehensive tests for nested type aliases and late static binding scenarios.

Author: rcalicdan

src/Internal/Checker/ParamChecker.php

@@ -17,6 +17,7 @@
 use TypePHP\Internal\TypeFormatter;
 use TypePHP\Resolver\SpecialTypeResolver;
 use TypePHP\Resolver\TemplateManager;
+use TypePHP\Resolver\TemplateSubstitutor;
 use TypePHP\Validator\TypeValidatorRegistry;
 
 /**
@@ -78,6 +79,9 @@ public static function checkParams(string $function, array $vars, object|string|
             TemplateManager::resolveInheritedTemplates($thisObj, $declaringClass);
         }
 
+        $boundTemplates = TemplateManager::getBoundTemplates($effectiveFunction, $thisObj, $templates);
+        $declaredTemplates = $templates;
+
         foreach ($contract['types'] as $paramName => $typeNode) {
             if (! \array_key_exists($paramName, $vars)) {
                 continue;
@@ -94,6 +98,18 @@ public static function checkParams(string $function, array $vars, object|string|
                 $typeNode = $aliases[$typeNode->name];
             }
 
+            $isClassStringT = ($typeNode instanceof GenericTypeNode && self::isClassStringTemplate($typeNode, $templates));
+
+            $isBareTemplate = ($typeNode instanceof IdentifierTypeNode && isset($templates[$typeNode->name]))
+                || ($typeNode instanceof ArrayTypeNode && $typeNode->type instanceof IdentifierTypeNode && isset($templates[$typeNode->type->name]));
+
+            $shouldSkipTemplateSub = $isBareTemplate || $isClassStringT;
+
+            if (! $shouldSkipTemplateSub && (\count($boundTemplates) > 0 || \count($declaredTemplates) > 0)) {
+                $typeNode = TemplateSubstitutor::substitute($typeNode, $boundTemplates, $declaredTemplates);
+                $typeNode = SpecialTypeResolver::resolve($typeNode, $effectiveFunction, $thisObj);
+            }
+
             if ($typeNode instanceof GenericTypeNode && self::isClassStringTemplate($typeNode, $templates)) {
                 $err = self::resolveClassStringTemplate($typeNode, $val, $paramName, $effectiveFunction, $thisObj, $templates);
                 if ($err !== null) {
@@ -342,4 +358,4 @@ private static function resolveTemplateParam(TypeNode $typeNode, mixed $val, str
 
         return null;
     }
-}
+}

src/Internal/Checker/ReturnChecker.php

@@ -193,4 +193,4 @@ private static function resolveConditionalReturnType(
 
         return $returnTypeNode;
     }
-}
+}

src/Internal/RuntimeTypeChecker.php

@@ -210,4 +210,4 @@ public static function getRegistry(): TypeValidatorRegistry
     {
         return self::$registry ??= new TypeValidatorRegistry();
     }
-}
+}

src/Internal/Visitor/FunctionContractInjector.php

@@ -545,4 +545,4 @@ public function enterNode(Node $n): int|array|null
 
         return $newStmts;
     }
-}
+}

src/Resolver/SpecialTypeResolver.php

@@ -281,6 +281,7 @@ private static function getReflectionContext(\ReflectionClass|\ReflectionFunctio
 
     /**
      * @param \ReflectionClass<object>|\ReflectionFunction|\ReflectionMethod $ref
+     * @param \ReflectionClass<object>|\ReflectionFunction|\ReflectionMethod|string $context
      */
     private static function resolveIdentifier(
         IdentifierTypeNode $node,
@@ -359,7 +360,6 @@ private static function resolveConstType(ConstTypeNode $node, ?string $declaring
      */
     private static function resolveOffsetAccess(OffsetAccessTypeNode $node, \ReflectionClass|\ReflectionFunction|\ReflectionMethod|string $context, ?object $thisObj): TypeNode
     {
-        $ref = self::getReflectionContext($context);
         $baseType = self::resolve($node->type, $context, $thisObj);
         $offsetType = self::resolve($node->offset, $context, $thisObj);
 
@@ -1004,4 +1004,4 @@ private static function parseFileMetadata(string $fileName, string $source): voi
             // Silently fall back to empty metadata if parsing fails
         }
     }
-}
+}

tests/Fixtures/Services/AdminEntityFactory.php

@@ -6,4 +6,4 @@
 
 class AdminEntityFactory extends BaseEntityFactory
 {
-}
+}

tests/Fixtures/Services/AdminGenericFactory.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Services;
+
+/**
+ * @template T
+ *
+ * @extends BaseGenericFactory<T>
+ */
+class AdminGenericFactory extends BaseGenericFactory
+{
+}

tests/Fixtures/Services/BaseEntityFactory.php

@@ -76,4 +76,4 @@ public function withBadSetting(): object
     {
         return new AdminEntityFactory();
     }
-}
+}

tests/Fixtures/Services/BaseGenericFactory.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Services;
+
+use stdClass;
+use TypePHP\Tests\Fixtures\Generics\Producer;
+
+/**
+ * @template T
+ */
+abstract class BaseGenericFactory
+{
+    /**
+     * @param T $item
+     */
+    public function __construct(public mixed $item)
+    {
+    }
+
+    /**
+     * Static factory creating an instance of static<TValue>
+     *
+     * @template TValue
+     *
+     * @param TValue $value
+     *
+     * @return static<TValue>
+     */
+    public static function of(mixed $value): static
+    {
+        return new static($value);
+    }
+
+    /**
+     * Static factory returning wrong item violating generic T
+     *
+     * @template TValue
+     *
+     * @param TValue $value
+     *
+     * @return static<TValue>
+     */
+    public static function ofBadItem(mixed $value): static
+    {
+        return new static(new stdClass());
+    }
+
+    /**
+     * Method returning Producer holding static instance: Producer<static<T>>
+     *
+     * @return Producer<static<T>>
+     */
+    public function toProducer(): Producer
+    {
+        return new Producer($this);
+    }
+
+    /**
+     * Method returning Producer holding sibling instance
+     *
+     * @return Producer<static<T>>
+     */
+    public function toBadProducer(): Producer
+    {
+        return new Producer(new AdminGenericFactory($this->item));
+    }
+}

tests/Fixtures/Services/BaseGenericMap.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Services;
+
+/**
+ * @template K of array-key
+ * @template V
+ */
+abstract class BaseGenericMap
+{
+    /**
+     * @param array<K, V> $entries
+     */
+    public function __construct(public array $entries = [])
+    {
+    }
+
+    /**
+     * Static factory creating an instance with multiple bound templates
+     *
+     * @template TKey of array-key
+     * @template TVal
+     *
+     * @param TKey $key
+     * @param TVal $val
+     *
+     * @return static<TKey, TVal>
+     */
+    public static function fromEntry(mixed $key, mixed $val): static
+    {
+        return new static([$key => $val]);
+    }
+
+    /**
+     * Factory returning Array Shape holding generic static instance
+     *
+     * @template TKey of array-key
+     * @template TVal
+     *
+     * @param TKey $key
+     * @param TVal $val
+     *
+     * @return array{instance: static<TKey, TVal>, count: positive-int}
+     */
+    public static function toShape(mixed $key, mixed $val): array
+    {
+        return [
+            'instance' => new static([$key => $val]),
+            'count' => 1,
+        ];
+    }
+
+    /**
+     * Factory returning bad shape with invalid count
+     *
+     * @template TKey of array-key
+     * @template TVal
+     *
+     * @param TKey $key
+     * @param TVal $val
+     *
+     * @return array{instance: static<TKey, TVal>, count: positive-int}
+     */
+    public static function toBadShape(mixed $key, mixed $val): array
+    {
+        return [
+            'instance' => new static([$key => $val]),
+            'count' => -1, // Violates positive-int in shape
+        ];
+    }
+}