Improve field errors

Author: Kirill Nesmeyanov

src/Exception/Mapping/InvalidFieldTypeValueException.php

@@ -7,6 +7,8 @@
 use TypeLang\Mapper\Runtime\Context\LocalContext;
 use TypeLang\Mapper\Runtime\Path\PathInterface;
 use TypeLang\Parser\Node\Stmt\TypeStatement;
+use TypeLang\Parser\Traverser;
+use TypeLang\Parser\Traverser\TypeMapVisitor;
 
 class InvalidFieldTypeValueException extends RuntimeException implements
     FieldExceptionInterface,
@@ -15,7 +17,9 @@ class InvalidFieldTypeValueException extends RuntimeException implements
 {
     use FieldProvider;
     use ValueProvider;
-    use TypeProvider;
+    use TypeProvider {
+        TypeProvider::explain as private explainExpectedType;
+    }
 
     /**
      * @var int
@@ -34,6 +38,7 @@ public function __construct(
         protected readonly string $field,
         protected readonly mixed $value,
         protected readonly TypeStatement $expected,
+        protected readonly TypeStatement $object,
         PathInterface $path,
         string $template,
         int $code = 0,
@@ -54,28 +59,17 @@ public static function createFromPath(
         string $field,
         mixed $value,
         TypeStatement $expected,
+        TypeStatement $object,
         PathInterface $path,
         ?\Throwable $previous = null
     ): self {
-        $template = 'Passed value of field {{field}} must be of type {{expected}}, but {{value}} given';
-
-        if ($previous instanceof FieldExceptionInterface) {
-            $field = $previous->getField();
-            $path = $previous->getPath();
-
-            if ($previous instanceof ValueExceptionInterface) {
-                $value = $previous->getValue();
-            }
-
-            if ($previous instanceof MappingExceptionInterface) {
-                $expected = $previous->getExpectedType();
-            }
-        }
+        $template = 'Passed value in {{field}} of {{object}} must be of type {{expected}}, but {{value}} given';
 
         return new self(
             field: $field,
             value: $value,
             expected: $expected,
+            object: $object,
             path: $path,
             template: $template,
             code: self::CODE_ERROR_INVALID_VALUE,
@@ -90,15 +84,29 @@ public static function createFromContext(
         string $field,
         mixed $value,
         TypeStatement $expected,
+        TypeStatement $object,
         LocalContext $context,
         ?\Throwable $previous = null,
     ): self {
         return self::createFromPath(
             field: $field,
             value: $value,
             expected: $expected,
+            object: $object,
             path: clone $context->getPath(),
             previous: $previous,
         );
     }
+
+    public function explain(callable $transform): self
+    {
+        $this->explainExpectedType($transform);
+
+        Traverser::through(
+            visitor: new TypeMapVisitor($transform(...)),
+            nodes: [$this->object],
+        );
+
+        return $this;
+    }
 }

src/Exception/Mapping/MissingFieldValueException.php

@@ -53,7 +53,7 @@ public static function createFromPath(
         PathInterface $path,
         ?\Throwable $previous = null,
     ): self {
-        $template = 'Object of type {{expected}} requires field {{field}}';
+        $template = 'Object of type {{expected}} requires missing field {{field}}';
 
         return new self(
             expected: $expected,

src/Mapping/Driver/DocBlockDriver.php

@@ -19,6 +19,10 @@
 use TypeLang\PHPDoc\Standard\VarTagFactory;
 use TypeLang\PHPDoc\Tag\Factory\TagFactory;
 
+/**
+ * Note: This driver requires installed "type-lang/phpdoc" and
+ *       "type-lang/phpdoc-standard-tags" Composer packages.
+ */
 final class DocBlockDriver extends LoadableDriver
 {
     /**

src/Mapping/Driver/ReflectionDriver.php

@@ -32,7 +32,6 @@ protected function load(\ReflectionClass $reflection, ClassMetadata $class, Repo
             $metadata = $class->getPropertyOrCreate($property->getName());
 
             $this->fillType($property, $metadata, $types);
-            $this->fillReadonlyModifier($property, $metadata);
             $this->fillDefaultValue($property, $metadata);
         }
     }
@@ -48,15 +47,6 @@ private function fillDefaultValue(\ReflectionProperty $property, PropertyMetadat
         $meta->setDefaultValue($default);
     }
 
-    private function fillReadonlyModifier(\ReflectionProperty $property, PropertyMetadata $meta): void
-    {
-        if (!$property->isReadOnly()) {
-            return;
-        }
-
-        $meta->markAsReadonly();
-    }
-
     /**
      * @throws PropertyTypeNotFoundException
      * @throws \InvalidArgumentException

src/Mapping/Metadata/PropertyMetadata.php

@@ -5,7 +5,7 @@
 namespace TypeLang\Mapper\Mapping\Metadata;
 
 use TypeLang\Mapper\Runtime\Context\LocalContext;
-use TypeLang\Mapper\Type\TypeInterface;
+use TypeLang\Parser\Node\Stmt\NamedTypeNode;
 use TypeLang\Parser\Node\Stmt\Shape\NamedFieldNode;
 use TypeLang\Parser\Node\Stmt\TypeStatement;
 
@@ -20,8 +20,6 @@ final class PropertyMetadata extends Metadata
 
     private bool $hasDefaultValue = false;
 
-    private bool $readonly = false;
-
     /**
      * @param non-empty-string $export
      */
@@ -44,7 +42,17 @@ public function getTypeStatement(LocalContext $context): ?TypeStatement
     {
         $info = $this->findTypeInfo();
 
-        return $info?->getTypeStatement();
+        if ($info === null) {
+            return null;
+        }
+
+        $statement = clone $info->getTypeStatement();
+
+        if ($context->isDetailedTypes() || !$statement instanceof NamedTypeNode) {
+            return $statement;
+        }
+
+        return new NamedTypeNode($statement->name);
     }
 
     /**
@@ -131,19 +139,6 @@ public function hasTypeInfo(): bool
         return $this->type !== null;
     }
 
-    /**
-     * Note: The prefix "find" is used to indicate that the {@see TypeInterface}
-     *       definition may be optional and method may return {@see null}.
-     *       The prefix "get" is used when the value is forced to be obtained
-     *       and should throw an exception if the type definition is missing.
-     *
-     * @api
-     */
-    public function findType(): ?TypeInterface
-    {
-        return $this->type?->getType();
-    }
-
     /**
      * Note: The prefix "find" is used to indicate that the {@see TypeMetadata}
      *       definition may be optional and method may return {@see null}.
@@ -195,20 +190,4 @@ public function hasDefaultValue(): bool
     {
         return $this->hasDefaultValue;
     }
-
-    /**
-     * @api
-     */
-    public function markAsReadonly(bool $readonly = true): void
-    {
-        $this->readonly = $readonly;
-    }
-
-    /**
-     * @api
-     */
-    public function isReadonly(): bool
-    {
-        return $this->readonly;
-    }
 }

src/Type/ObjectType.php

@@ -105,6 +105,7 @@ protected function normalizeObject(object $object, LocalContext $context): array
                     field: $meta->getExportName(),
                     value: $fieldValue,
                     expected: $info->getTypeStatement(),
+                    object: $this->metadata->getTypeStatement($context),
                     context: $context,
                     previous: $e,
                 );
@@ -199,6 +200,7 @@ private function denormalizeObject(array $value, object $object, LocalContext $c
                             field: $meta->getExportName(),
                             value: $fieldValue,
                             expected: $info->getTypeStatement(),
+                            object: $this->metadata->getTypeStatement($context),
                             context: $context,
                             previous: $e,
                         );

src/Type/ObjectType/PropertyAccessor/ReflectionPropertyAccessor.php

@@ -46,10 +46,6 @@ public function setValue(object $object, PropertyMetadata $meta, mixed $value):
 
     public function isWritable(object $object, PropertyMetadata $meta): bool
     {
-        if ($meta->isReadonly()) {
-            return false;
-        }
-
         try {
             $property = $this->getProperty($object, $meta);
 

tests/Unit/Mapping/Metadata/PropertyTest.php

@@ -58,51 +58,36 @@ public function testDefaultValue(): void
         self::assertFalse($property->hasDefaultValue());
     }
 
-    public function testReadonlyModifier(): void
-    {
-        $property = new PropertyMetadata('foo');
-
-        self::assertFalse($property->isReadonly());
-
-        $property->markAsReadonly();
-
-        self::assertTrue($property->isReadonly());
-
-        $property->markAsReadonly(false);
-
-        self::assertFalse($property->isReadonly());
-
-        $property->markAsReadonly(true);
-
-        self::assertTrue($property->isReadonly());
-    }
-
     public function testType(): void
     {
         $property = new PropertyMetadata('foo');
 
-        self::assertNull($property->findType());
+        self::assertNull($property->findTypeInfo());
         self::assertFalse($property->hasTypeInfo());
 
         $property = new PropertyMetadata('foo', new TypeMetadata(
             type: $type = new NullType(),
-            statement: new NullLiteralNode(),
+            statement: $statement = new NullLiteralNode(),
         ));
 
-        self::assertSame($type, $property->findType());
+        self::assertNotNull($info = $property->findTypeInfo());
+        self::assertSame($type, $info->getType());
+        self::assertSame($statement, $info->getTypeStatement());
         self::assertTrue($property->hasTypeInfo());
 
         $property->setTypeInfo(new TypeMetadata(
             type: new NullType(),
             statement: new NullLiteralNode()
         ));
 
-        self::assertNotSame($type, $property->findType());
+        self::assertNotNull($info = $property->findTypeInfo());
+        self::assertNotSame($type, $info->getType());
+        self::assertNotSame($statement, $info->getTypeStatement());
         self::assertTrue($property->hasTypeInfo());
 
         $property->removeTypeInfo();
 
-        self::assertNull($property->findType());
+        self::assertNull($property->findTypeInfo());
         self::assertFalse($property->hasTypeInfo());
     }
 }

tests/Unit/Type/TypeTestCase.php

@@ -8,7 +8,7 @@
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Group;
 use TypeLang\Mapper\Exception\Definition\TypeNotFoundException;
-use TypeLang\Mapper\Exception\Mapping\MappingException;
+use TypeLang\Mapper\Exception\Mapping\RuntimeException;
 use TypeLang\Mapper\Runtime\Context\Context;
 use TypeLang\Mapper\Runtime\Context\Direction;
 use TypeLang\Mapper\Runtime\Context\LocalContext;
@@ -48,14 +48,14 @@ protected function getDenormalizationExpectation(mixed $value, ValueType $type,
 
     protected function expectCastIfNonStrict(mixed $expected, Context $ctx): mixed
     {
-        $this->expectException(MappingException::class);
+        $this->expectException(RuntimeException::class);
 
         return "<\0MUST_THROW_ERROR(" . __FUNCTION__ . ")\0>";
     }
 
     protected function expectMappingError(): mixed
     {
-        $this->expectException(MappingException::class);
+        $this->expectException(RuntimeException::class);
 
         return "<\0MUST_THROW_ERROR(" . __FUNCTION__ . ")\0>";
     }