Implement generic collections and enhance type validation; add tests for Shopware entity hierarchy and generic placeholder binding

Author: rcalicdan

src/Internal/Checker/ParamChecker.php

@@ -549,6 +549,13 @@ private static function resolveTemplateParam(
                 return null;
             }
 
+            if ($expectedTypeNode instanceof IdentifierTypeNode && $expectedTypeNode->name === $templateName) {
+                $inferredType = TemplateManager::inferTypeFromValue($val);
+                TemplateManager::bindTemplate($function, $targetObj, $templateName, $inferredType);
+
+                return null;
+            }
+
             if ($isVariadic && \is_array($val)) {
                 foreach ($val as $idx => $item) {
                     $err = $registry->validate($item, $expectedTypeNode, $function . '(): Argument $' . $paramName . '[' . $idx . '] (template ' . $templateName . ' = ' . $expectedTypeNode . ')');

src/Resolver/SpecialTypeResolver.php

@@ -34,7 +34,9 @@
 use TypePHP\Internal\TypeFormatter;
 
 /**
- * @internal Resolves special type identifiers (self, static, parent, FQCNs) against Reflection or file contexts.
+ * Resolves special type identifiers (self, static, parent, FQCNs) against Reflection or file contexts.
+ *
+ * @internal
  */
 final class SpecialTypeResolver
 {
@@ -980,7 +982,7 @@ public static function resolveFqcnForFile(string $name, string $file): string
     /**
      * Checks if a type name is a built-in PHP or PHPDoc type keyword.
      */
-    private static function isBuiltInTypeKeyword(string $name): bool
+    public static function isBuiltInTypeKeyword(string $name): bool
     {
         return isset(self::BUILTIN_TYPE_KEYWORDS[strtolower($name)]);
     }

src/Resolver/TemplateManager.php

@@ -352,11 +352,21 @@ private static function bindSingleTemplateArgument(
             return null;
         }
 
+        $expectedTypeNode = $typeNode->genericTypes[$index];
+
+        if ($expectedTypeNode instanceof IdentifierTypeNode) {
+            $isBuiltIn = SpecialTypeResolver::isBuiltInTypeKeyword($expectedTypeNode->name);
+            $isRealType = class_exists($expectedTypeNode->name) || interface_exists($expectedTypeNode->name) || enum_exists($expectedTypeNode->name) || trait_exists($expectedTypeNode->name);
+
+            if (! $isBuiltIn && ! $isRealType) {
+                return null;
+            }
+        }
+
         if (self::$instanceTemplateBindings === null) {
             self::$instanceTemplateBindings = new WeakMap();
         }
 
-        $expectedTypeNode = $typeNode->genericTypes[$index];
         $usageVariance = $typeNode->variances[$index] ?? GenericTypeNode::VARIANCE_INVARIANT;
         $declaredVariance = $classVariances[$templateTag->name] ?? GenericTypeNode::VARIANCE_INVARIANT;
 
@@ -505,8 +515,17 @@ private static function bindInheritedGenericTag(
                 if (isset($genericTypeNode->genericTypes[$idx])) {
                     $resolved = self::resolveTypeNodeAst($genericTypeNode->genericTypes[$idx], $hierClass);
 
-                    if ($resolved instanceof IdentifierTypeNode && isset($declaredTemplateNames[$resolved->name])) {
-                        continue;
+                    if ($resolved instanceof IdentifierTypeNode) {
+                        $isBuiltIn = SpecialTypeResolver::isBuiltInTypeKeyword($resolved->name);
+                        $isRealType = class_exists($resolved->name) || interface_exists($resolved->name) || enum_exists($resolved->name) || trait_exists($resolved->name);
+
+                        if (! $isBuiltIn && ! $isRealType) {
+                            continue;
+                        }
+
+                        if (isset($declaredTemplateNames[$resolved->name])) {
+                            continue;
+                        }
                     }
 
                     $bindings[$templateName] = $resolved;
@@ -837,4 +856,4 @@ private static function getTypeParserComponents(): array
 
         return [$typeParser, $lexer];
     }
-}
+}

tests/Fixtures/Collections/ShopwareCollection.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Collections;
+
+use Closure;
+use Countable;
+use IteratorAggregate;
+use Traversable;
+
+/**
+ * @template TElement
+ * @template TKey of array-key = array-key
+ *
+ * @implements IteratorAggregate<TKey, TElement>
+ */
+abstract class ShopwareCollection implements IteratorAggregate, Countable
+{
+    /**
+     * @var array<TKey, TElement>
+     */
+    protected array $elements = [];
+
+    /**
+     * Directly populates elements without method contract inference
+     */
+    public function setElementsDirectly(array $elements): void
+    {
+        $this->elements = $elements;
+    }
+
+    /**
+     * @param TElement $element
+     */
+    protected function validateType(mixed $element): void
+    {
+    }
+
+    /**
+     * @param Closure(TElement): bool $closure
+     */
+    public function filter(Closure $closure): static
+    {
+        $filtered = array_filter($this->elements, $closure);
+
+        $instance = new static();
+        $instance->setElementsDirectly($filtered);
+
+        return $instance;
+    }
+
+    /**
+     * @return Traversable<TElement>
+     */
+    public function getIterator(): Traversable
+    {
+        yield from $this->elements;
+    }
+
+    public function count(): int
+    {
+        return \count($this->elements);
+    }
+}

tests/Fixtures/Collections/ShopwareEntityCollection.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Collections;
+
+/**
+ * @template TElement of object
+ *
+ * @extends ShopwareCollection<TElement, string>
+ */
+class ShopwareEntityCollection extends ShopwareCollection
+{
+    /**
+     * @param iterable<TElement> $elements
+     */
+    public function __construct(iterable $elements = [])
+    {
+        foreach ($elements as $key => $element) {
+            $this->validateType($element);
+            $keyStr = \is_string($key) ? $key : ('id_' . $key);
+            $this->elements[$keyStr] = $element;
+        }
+    }
+}

tests/Fixtures/Collections/ShopwareEntitySearchResult.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Collections;
+
+/**
+ * @template TElement of object
+ *
+ * @extends ShopwareEntityCollection<TElement>
+ */
+class ShopwareEntitySearchResult extends ShopwareEntityCollection
+{
+    public function __construct(?ShopwareEntityCollection $entities = null)
+    {
+        parent::__construct($entities ?? []);
+    }
+}

tests/Fixtures/Collections/SpecificDogSearchResult.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Collections;
+
+use TypePHP\Tests\Fixtures\Domain\Dog;
+
+/**
+ * Concrete Leaf Class binding TElement to Dog
+ *
+ * @extends ShopwareEntitySearchResult<Dog>
+ */
+class SpecificDogSearchResult extends ShopwareEntitySearchResult
+{
+}

tests/Fixtures/Generics/ChildGenericBag.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Generics;
+
+/**
+ * Child class passing generic placeholder TElement up to MidGenericBag<TElement>
+ *
+ * @template TElement of object
+ *
+ * @extends MidGenericBag<TElement>
+ */
+class ChildGenericBag extends MidGenericBag
+{
+}

tests/Fixtures/Generics/MidGenericBag.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Generics;
+
+/**
+ * Middle class passing generic placeholder TElement up to RootGenericBag<TElement>
+ *
+ * @template TElement of object
+ *
+ * @extends RootGenericBag<TElement>
+ */
+abstract class MidGenericBag extends RootGenericBag
+{
+}

tests/Fixtures/Generics/RootGenericBag.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Generics;
+
+/**
+ * @template TElement of object
+ */
+abstract class RootGenericBag
+{
+    /**
+     * @param TElement $element
+     */
+    public function addItem(object $element): bool
+    {
+        return true;
+    }
+}