Add class subtype normalization

Author: Kirill Nesmeyanov

src/Exception/Mapping/NonInstantiatableObjectException.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Exception\Mapping;
+
+use TypeLang\Mapper\Runtime\Context;
+use TypeLang\Mapper\Runtime\Path\PathInterface;
+use TypeLang\Parser\Node\Stmt\TypeStatement;
+
+class NonInstantiatableObjectException extends ObjectException
+{
+    /**
+     * @param \ReflectionClass<object> $value
+     */
+    public function __construct(
+        TypeStatement $expected,
+        \ReflectionClass $value,
+        PathInterface $path,
+        string $template,
+        int $code = 0,
+        ?\Throwable $previous = null,
+    ) {
+        parent::__construct($expected, $value, $path, $template, $code, $previous);
+    }
+
+    /**
+     * @param \ReflectionClass<object> $value
+     */
+    public static function createFromPath(
+        ?TypeStatement $expected,
+        \ReflectionClass $value,
+        PathInterface $path,
+        ?\Throwable $previous = null,
+    ): self {
+        $template = \sprintf('Unable to instantiate %s of {{expected}}', match (true) {
+            $value->isAbstract() => 'abstract class',
+            $value->isInterface() => 'interface',
+            default => 'unknown non-instantiable type',
+        });
+
+        return new self(
+            expected: $expected ?? self::mixedTypeStatement(),
+            value: $value,
+            path: $path,
+            template: $template,
+            previous: $previous,
+        );
+    }
+
+    /**
+     * @param \ReflectionClass<object> $value
+     */
+    public static function createFromContext(
+        ?TypeStatement $expected,
+        \ReflectionClass $value,
+        Context $context,
+        ?\Throwable $previous = null,
+    ): self {
+        return self::createFromPath(
+            expected: $expected,
+            value: $value,
+            path: $context->getPath(),
+            previous: $previous,
+        );
+    }
+}

src/Type/Builder/ClassTypeBuilder.php

@@ -68,32 +68,12 @@ public function build(
         /** @var class-string<T> $class */
         $class = $statement->name->toString();
 
-        $reflection = new \ReflectionClass($class);
-
-        $metadata = $this->driver->getClassMetadata(
-            class: $reflection,
-            types: $types,
-            parser: $parser,
-        );
-
-        $discriminator = $metadata->findDiscriminator();
-
-        if ($discriminator === null && !$reflection->isInstantiable()) {
-            throw InternalTypeException::becauseInternalTypeErrorOccurs(
-                type: $statement,
-                message: \vsprintf('%s "%s" expects a discriminator map to be able to be created', [
-                    match (true) {
-                        $reflection->isAbstract() => 'Non-creatable abstract class',
-                        $reflection->isInterface() => 'Non-creatable interface',
-                        default => 'Unknown non-instantiable type',
-                    },
-                    $reflection->getName(),
-                ]),
-            );
-        }
-
         return new ClassType(
-            metadata: $metadata,
+            metadata: $this->driver->getClassMetadata(
+                class: new \ReflectionClass($class),
+                types: $types,
+                parser: $parser,
+            ),
             accessor: $this->accessor,
             instantiator: $this->instantiator,
         );

src/Type/ClassType/ClassInstantiator/ClassInstantiatorInterface.php

@@ -4,7 +4,9 @@
 
 namespace TypeLang\Mapper\Type\ClassType\ClassInstantiator;
 
+use TypeLang\Mapper\Exception\Mapping\NonInstantiatableObjectException;
 use TypeLang\Mapper\Mapping\Metadata\ClassMetadata;
+use TypeLang\Mapper\Runtime\Context;
 
 interface ClassInstantiatorInterface
 {
@@ -14,7 +16,8 @@ interface ClassInstantiatorInterface
      * @param ClassMetadata<T> $class
      *
      * @return T
+     * @throws NonInstantiatableObjectException occurs in case of object is not instantiatable
      * @throws \Throwable occurs for some reason when creating an object
      */
-    public function instantiate(ClassMetadata $class): object;
+    public function instantiate(ClassMetadata $class, Context $context): object;
 }

src/Type/ClassType/ClassInstantiator/ReflectionClassInstantiator.php

@@ -4,14 +4,24 @@
 
 namespace TypeLang\Mapper\Type\ClassType\ClassInstantiator;
 
+use TypeLang\Mapper\Exception\Mapping\NonInstantiatableObjectException;
 use TypeLang\Mapper\Mapping\Metadata\ClassMetadata;
+use TypeLang\Mapper\Runtime\Context;
 
 final class ReflectionClassInstantiator implements ClassInstantiatorInterface
 {
-    public function instantiate(ClassMetadata $class): object
+    public function instantiate(ClassMetadata $class, Context $context): object
     {
         $reflection = new \ReflectionClass($class->getName());
 
+        if (!$reflection->isInstantiable()) {
+            throw NonInstantiatableObjectException::createFromContext(
+                expected: $class->getTypeStatement($context),
+                value: $reflection,
+                context: $context,
+            );
+        }
+
         return $reflection->newInstanceWithoutConstructor();
     }
 }

src/Type/ClassType/ClassTypeDenormalizer.php

@@ -65,7 +65,7 @@ public function cast(mixed $value, Context $context): mixed
 
         $entrance = $context->enter($value, new ObjectEntry($this->metadata->getName()));
 
-        $instance = $this->instantiator->instantiate($this->metadata);
+        $instance = $this->instantiator->instantiate($this->metadata, $context);
 
         $this->denormalizeObject($value, $instance, $entrance);
 

src/Type/ClassType/ClassTypeNormalizer.php

@@ -51,6 +51,13 @@ public function cast(mixed $value, Context $context): object|array
             );
         }
 
+        // Subtype normalization
+        if ($value::class !== $className) {
+            /** @var object|array<non-empty-string, mixed> */
+            return $context->getTypeByValue($value)
+                ->cast($value, $context);
+        }
+
         $entrance = $context->enter($value, new ObjectEntry($this->metadata->getName()));
 
         $result = $this->normalizeObject($value, $entrance);