WIP: fixes

Author: JanTvrdik

src/Compiler/Php/PhpCodeBuilder.php

@@ -67,9 +67,12 @@
 use function is_array;
 use function is_object;
 use function ksort;
+use function serialize;
 use function str_ends_with;
 use function strrpos;
 use function substr;
+use function unserialize;
+
 
 class PhpCodeBuilder extends BuilderFactory
 {
@@ -430,8 +433,18 @@ public function mapperMethod(string $methodName, MapperCompiler $mapperCompiler)
         $this->importType($inputType);
         $this->importType($outputType);
 
-        $nativeInputType = PhpDocTypeUtils::toNativeType($inputType, $phpDocInputTypeUseful);
-        $nativeOutputType = PhpDocTypeUtils::toNativeType($outputType, $phpDocOutputTypeUseful);
+        $clonedGenericParameters = [];
+        foreach ($this->genericParameters as $genericParameter) {
+            $clonedGenericParameter = unserialize(serialize($genericParameter));
+            $clonedGenericParameters[] = $clonedGenericParameter;
+
+            if ($clonedGenericParameter->bound !== null) {
+                $this->importType($clonedGenericParameter->bound);
+            }
+        }
+
+        $nativeInputType = PhpDocTypeUtils::toNativeType($inputType, $clonedGenericParameters, $phpDocInputTypeUseful);
+        $nativeOutputType = PhpDocTypeUtils::toNativeType($outputType, $clonedGenericParameters, $phpDocOutputTypeUseful);
 
         $phpDoc = $this->phpDoc([
             $phpDocInputTypeUseful ? "@param  {$inputType} \${$dataVarName}" : null,

src/Compiler/Type/PhpDocTypeUtils.php

@@ -33,6 +33,7 @@
 use ReflectionNamedType;
 use ReflectionType;
 use ReflectionUnionType;
+use ShipMonk\InputMapper\Compiler\Mapper\GenericMapperParameter;
 use ShipMonk\InputMapper\Runtime\Optional;
 use ShipMonk\InputMapper\Runtime\OptionalNone;
 use ShipMonk\InputMapper\Runtime\OptionalSome;
@@ -133,13 +134,24 @@ public static function fromReflectionType(ReflectionType $reflectionType): TypeN
         return new IdentifierTypeNode('mixed');
     }
 
-    public static function toNativeType(TypeNode $type, ?bool &$phpDocUseful): ComplexType|Identifier|Name
+
+    /**
+     * @param  list<GenericMapperParameter> $genericParameters
+     */
+    public static function toNativeType(TypeNode $type, array $genericParameters, ?bool &$phpDocUseful): ComplexType|Identifier|Name
     {
         if ($phpDocUseful === null) {
             $phpDocUseful = false;
         }
 
         if ($type instanceof IdentifierTypeNode) {
+            foreach ($genericParameters as $genericParameter) {
+                if ($genericParameter->name === $type->name) {
+                    $phpDocUseful = true;
+                    return self::toNativeType($genericParameter->bound ?? new IdentifierTypeNode('mixed'), $genericParameters, $phpDocUseful);
+                }
+            }
+
             if (!self::isKeyword($type)) {
                 return new Name($type->name);
             }
@@ -161,7 +173,7 @@ public static function toNativeType(TypeNode $type, ?bool &$phpDocUseful): Compl
         }
 
         if ($type instanceof NullableTypeNode) {
-            return NativeTypeUtils::createNullable(self::toNativeType($type->type, $phpDocUseful));
+            return NativeTypeUtils::createNullable(self::toNativeType($type->type, $genericParameters, $phpDocUseful));
         }
 
         if ($type instanceof ArrayTypeNode || $type instanceof ArrayShapeNode) {
@@ -181,14 +193,14 @@ public static function toNativeType(TypeNode $type, ?bool &$phpDocUseful): Compl
 
         if ($type instanceof GenericTypeNode) {
             $phpDocUseful = true;
-            return self::toNativeType($type->type, $phpDocUseful);
+            return self::toNativeType($type->type, $genericParameters, $phpDocUseful);
         }
 
         if ($type instanceof UnionTypeNode) {
             $types = [];
 
             foreach ($type->types as $inner) {
-                $types[] = self::toNativeType($inner, $phpDocUseful);
+                $types[] = self::toNativeType($inner, $genericParameters, $phpDocUseful);
             }
 
             return NativeTypeUtils::createUnion(...$types);
@@ -198,7 +210,7 @@ public static function toNativeType(TypeNode $type, ?bool &$phpDocUseful): Compl
             $types = [];
 
             foreach ($type->types as $inner) {
-                $types[] = self::toNativeType($inner, $phpDocUseful);
+                $types[] = self::toNativeType($inner, $genericParameters, $phpDocUseful);
             }
 
             return NativeTypeUtils::createIntersection(...$types);

src/Runtime/MapperProvider.php

@@ -4,6 +4,7 @@
 
 use LogicException;
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use RuntimeException;
 use ShipMonk\InputMapper\Compiler\MapperFactory\DefaultMapperCompilerFactoryProvider;
 use ShipMonk\InputMapper\Compiler\MapperFactory\MapperCompilerFactoryProvider;
@@ -79,6 +80,16 @@ public function getGeneric(string $inputClassName, array $innerMappers): Mapper
         return $mapper;
     }
 
+//    /**
+//     * @return Mapper<mixed>
+//     */
+//    public function getForTypeNode(TypeNode $typeNode): Mapper
+//    {
+//        $key = (string) $typeNode;
+//        $mapper = $this->mappers[$key] ??= $this->create($inputClassName, $innerMappers);
+//        return $mapper;
+//    }
+
     /**
      * @template T of object
      * @param  class-string<T>                            $inputClassName
@@ -114,18 +125,13 @@ private function create(string $inputClassName, array $innerMappers): Mapper
         $mapperClassName = $this->getMapperClass($inputClassName);
 
         if (!class_exists($mapperClassName, autoload: false)) {
-            $this->load($inputClassName, $mapperClassName);
+            $this->load(new IdentifierTypeNode($inputClassName), $mapperClassName);
         }
 
         return new $mapperClassName($this, $innerMappers);
     }
 
-    /**
-     * @template T of object
-     * @param class-string<T>         $inputClassName
-     * @param class-string<Mapper<T>> $mapperClassName
-     */
-    private function load(string $inputClassName, string $mapperClassName): void
+    private function load(TypeNode $type, string $mapperClassName): void
     {
         $path = $this->getMapperPath($mapperClassName);
 
@@ -148,7 +154,7 @@ private function load(string $inputClassName, string $mapperClassName): void
         }
 
         if (!is_file($path) || $this->autoRefresh) {
-            $code = $this->compile($inputClassName, $mapperClassName);
+            $code = $this->compile($type, $mapperClassName);
 
             if (file_put_contents("$path.tmp", $code) !== strlen($code) || !rename("$path.tmp", $path)) {
                 @unlink("$path.tmp"); // @ file may not exist
@@ -163,15 +169,10 @@ private function load(string $inputClassName, string $mapperClassName): void
         flock($handle, LOCK_UN);
     }
 
-    /**
-     * @template T of object
-     * @param class-string<T>         $inputClassName
-     * @param class-string<Mapper<T>> $mapperClassName
-     */
-    private function compile(string $inputClassName, string $mapperClassName): string
+    private function compile(TypeNode $type, string $mapperClassName): string
     {
         $mapperCompilerFactory = $this->mapperCompilerFactoryProvider->get();
-        $mapperCompiler = $mapperCompilerFactory->create(new IdentifierTypeNode($inputClassName));
+        $mapperCompiler = $mapperCompilerFactory->create($type);
 
         $codeBuilder = new PhpCodeBuilder();
         $codePrinter = new PhpCodePrinter();

tests/Compiler/Type/PhpDocTypeUtilsTest.php

@@ -147,7 +147,7 @@ public function testToNativeType(
         bool $expectedIsPhpDocUseful
     ): void
     {
-        $nativeType = PhpDocTypeUtils::toNativeType($type, $phpDocUseful);
+        $nativeType = PhpDocTypeUtils::toNativeType($type, [], $phpDocUseful);
 
         self::assertEquals($expectedNative, $nativeType);
         self::assertSame($expectedIsPhpDocUseful, $phpDocUseful);