Better error reporting of missing 'typePropery' when using DiscriminatorMap (#257)

Author: joelwurtz

src/Exception/CannotCreateTargetException.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Exception;
+
+/**
+ * @author Joel Wurtz <[email protected]>
+ */
+final class CannotCreateTargetException extends RuntimeException
+{
+}

src/Generator/CreateTargetStatementsGenerator.php

@@ -40,8 +40,10 @@ public function __construct(
      *    ... // create object statements
      * }
      * ```
+     *
+     * @return list<Stmt>
      */
-    public function generate(GeneratorMetadata $metadata, VariableRegistry $variableRegistry): Stmt
+    public function generate(GeneratorMetadata $metadata, VariableRegistry $variableRegistry): array
     {
         $createObjectStatements = [];
 
@@ -56,9 +58,18 @@ public function generate(GeneratorMetadata $metadata, VariableRegistry $variable
 
         $createObjectStatements = array_values(array_filter($createObjectStatements));
 
-        return new Stmt\If_(new Expr\BinaryOp\Identical(new Expr\ConstFetch(new Name('null')), $variableRegistry->getResult()), [
-            'stmts' => $createObjectStatements,
-        ]);
+        if ($this->canUseTargetToPopulate($metadata)) {
+            return [new Stmt\If_(new Expr\BinaryOp\Identical(new Expr\ConstFetch(new Name('null')), $variableRegistry->getResult()), [
+                'stmts' => $createObjectStatements,
+            ])];
+        }
+
+        return $createObjectStatements;
+    }
+
+    public function canUseTargetToPopulate(GeneratorMetadata $metadata): bool
+    {
+        return !$this->discriminatorStatementsGeneratorTarget->supports($metadata);
     }
 
     private function targetAsArray(GeneratorMetadata $metadata): ?Stmt
@@ -346,6 +357,10 @@ private function constructorWithoutArgument(GeneratorMetadata $metadata): ?Stmt
             return null;
         }
 
+        if ($metadata->mapperMetadata->targetReflectionClass?->isInstantiable() === false) {
+            return null;
+        }
+
         return new Stmt\Expression(new Expr\Assign($metadata->variableRegistry->getResult(), new Expr\New_(new Name\FullyQualified($metadata->mapperMetadata->target))));
     }
 }

src/Generator/MapMethodStatementsGenerator.php

@@ -52,9 +52,13 @@ public function getStatements(GeneratorMetadata $metadata): array
 
         $statements = [$this->ifSourceIsNullReturnNull($metadata)];
         $statements = [...$statements, ...$this->handleCircularReference($metadata)];
-        $statements = [...$statements, ...$this->initializeTargetToPopulate($metadata)];
-        $statements = [...$statements, ...$this->initializeTargetFromProvider($metadata)];
-        $statements[] = $this->createObjectStatementsGenerator->generate($metadata, $variableRegistry);
+
+        if ($this->createObjectStatementsGenerator->canUseTargetToPopulate($metadata)) {
+            $statements = [...$statements, ...$this->initializeTargetToPopulate($metadata)];
+            $statements = [...$statements, ...$this->initializeTargetFromProvider($metadata)];
+        }
+
+        $statements = [...$statements, ...$this->createObjectStatementsGenerator->generate($metadata, $variableRegistry)];
 
         $addedDependenciesStatements = $this->handleDependencies($metadata);
 

src/Generator/Shared/DiscriminatorStatementsGenerator.php

@@ -4,6 +4,7 @@
 
 namespace AutoMapper\Generator\Shared;
 
+use AutoMapper\Exception\CannotCreateTargetException;
 use AutoMapper\Metadata\GeneratorMetadata;
 use AutoMapper\Transformer\TransformerInterface;
 use PhpParser\Node\Arg;
@@ -85,7 +86,7 @@ public function createTargetStatements(GeneratorMetadata $metadata): array
 
         // Generate the code that allows to put the type into the output variable,
         // so we are able to determine which mapper to use
-        [$output, $createObjectStatements] = $propertyMetadata->transformer->transform(
+        [$output, $discriminateStatements] = $propertyMetadata->transformer->transform(
             $fieldValueExpr,
             $variableRegistry->getResult(),
             $propertyMetadata,
@@ -94,7 +95,7 @@ public function createTargetStatements(GeneratorMetadata $metadata): array
         );
 
         foreach ($this->classDiscriminatorResolver->discriminatorMapperNamesIndexedByTypeValue($metadata, $this->fromSource) as $typeValue => $discriminatorMapperName) {
-            $createObjectStatements[] = new Stmt\If_(
+            $discriminateStatements[] = new Stmt\If_(
                 new Expr\BinaryOp\Identical(new Scalar\String_($typeValue), $output),
                 [
                     'stmts' => [
@@ -116,10 +117,29 @@ public function createTargetStatements(GeneratorMetadata $metadata): array
             );
         }
 
-        return $createObjectStatements;
+        $isDefinedExpression = $propertyMetadata->source->accessor?->getIsDefinedExpression($variableRegistry->getSourceInput());
+
+        if (!$isDefinedExpression) {
+            return $discriminateStatements;
+        }
+        $cannotCreateTarget = !($metadata->mapperMetadata->targetReflectionClass === null) && !$metadata->mapperMetadata->targetReflectionClass->isInstantiable();
+
+        $if = new Stmt\If_($isDefinedExpression, [
+            'stmts' => $discriminateStatements,
+        ]);
+
+        $statements = [$if];
+
+        if ($cannotCreateTarget) {
+            $statements[] = new Stmt\Expression(new Expr\Throw_(new Expr\New_(new Name(CannotCreateTargetException::class), [
+                new Arg(new Scalar\String_('Cannot create target object, because the target is abstract or an interface, and the property "' . $propertyMetadata->source->property . '" is not defined, or the value does not match any discriminator type.')),
+            ])));
+        }
+
+        return $statements;
     }
 
-    private function supports(GeneratorMetadata $metadata): bool
+    public function supports(GeneratorMetadata $metadata): bool
     {
         if (!$this->classDiscriminatorResolver->hasClassDiscriminator($metadata, $this->fromSource)) {
             return false;

src/Metadata/GeneratorMetadata.php

@@ -89,6 +89,10 @@ public function hasConstructor(): bool
             return false;
         }
 
+        if ($constructor->getDeclaringClass()->isInterface() || $constructor->getDeclaringClass()->isAbstract()) {
+            return false;
+        }
+
         $parameters = $constructor->getParameters();
         $mandatoryParameters = [];
 

tests/AutoMapperTest/DiscriminatorMapBadConfiguration/expected.data

@@ -0,0 +1,4 @@
+AutoMapper\Exception\CannotCreateTargetException {
+  +class: "AutoMapper\Exception\CannotCreateTargetException"
+  +message: "Cannot create target object, because the target is abstract or an interface, and the property "linkType" is not defined, or the value does not match any discriminator type."
+}

tests/AutoMapperTest/DiscriminatorMapBadConfiguration/map.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\AutoMapperTest\DiscriminatorMapBadConfiguration;
+
+use AutoMapper\Tests\AutoMapperBuilder;
+use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
+
+#[DiscriminatorMap('linkType', [
+    'default' => DefaultLinkType::class,
+])]
+abstract class LinkType
+{
+}
+
+class DefaultLinkType extends LinkType
+{
+    public function __construct(
+        public string $link,
+    ) {
+    }
+}
+
+$source = [
+    // There is a typo on the key `type`.
+    // It should be `linkType` instead of `type`.
+    'type' => 'default',
+    'link' => 'https://example.com',
+];
+
+try {
+    return AutoMapperBuilder::buildAutoMapper()->map($source, LinkType::class);
+} catch (\Throwable $th) {
+    return $th;
+}

tests/AutoMapperTest/DiscriminatorPopulate/expected.data

@@ -0,0 +1,6 @@
+AutoMapper\Tests\AutoMapperTest\DiscriminatorPopulate\LinkWrapper {
+  +link: AutoMapper\Tests\AutoMapperTest\DiscriminatorPopulate\DefaultLinkType {
+    +link: "https://example.com/new"
+    +description: "description"
+  }
+}

tests/AutoMapperTest/DiscriminatorPopulate/map.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\AutoMapperTest\DiscriminatorPopulate;
+
+use AutoMapper\MapperContext;
+use AutoMapper\Tests\AutoMapperBuilder;
+use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
+
+#[DiscriminatorMap('linkType', [
+    'default' => DefaultLinkType::class,
+])]
+abstract class LinkType
+{
+}
+
+class DefaultLinkType extends LinkType
+{
+    public function __construct(
+        public string $link,
+        public string $description = 'default',
+    ) {
+    }
+}
+
+class LinkWrapper
+{
+    public function __construct(
+        public LinkType $link,
+    ) {
+    }
+}
+
+$source = [
+    'link' => [
+        'linkType' => 'default',
+        'link' => 'https://example.com/new',
+    ],
+];
+
+$existingData = new LinkWrapper(new DefaultLinkType('https://example.com/old', 'description'));
+
+return AutoMapperBuilder::buildAutoMapper()->map($source, $existingData, [MapperContext::DEEP_TARGET_TO_POPULATE => true]);