fix: remove exception inheritance from UnresolvableType

Because `UnresolvableType` can be applied to any property, parameter or
function/method return type, it can be present in a class definition
hierarchy. This class definition can then be cached for better
application performance, meaning these `UnresolvableType` will be
present in the cache entry. This is a problem because an exception
contains a lot of information, including reflection instances which can
not be serialized and can break caching mechanisms that rely on
serialization.

`UnresolvableType` extending `LogicException` was not necessary, so it
is removed and the code relying on it has been adapted.

src/Definition/Repository/Cache/Compiler/TypeCompiler.php

@@ -163,7 +163,7 @@ public function compile(Type $type): string
                 return "new $class($enumName, $pattern, [$cases])";
             case $type instanceof UnresolvableType:
                 $raw = var_export($type->toString(), true);
-                $message = var_export($type->getMessage(), true);
+                $message = var_export($type->message(), true);
 
                 return "new $class($raw, $message)";
             default:

src/Mapper/Object/Exception/InvalidConstructorReturnType.php

@@ -16,8 +16,8 @@ public function __construct(FunctionDefinition $function)
         $returnType = $function->returnType();
 
         if ($returnType instanceof UnresolvableType) {
-            $message = $returnType->getMessage();
-            $previous = $returnType;
+            $message = $returnType->message();
+            $previous = $returnType->previous();
         } else {
             $message = "Invalid return type `{$returnType->toString()}` for constructor `{$function->signature()}`, it must be a valid class name.";
             $previous = null;

src/Type/Types/UnresolvableType.php

@@ -12,16 +12,13 @@
 use Throwable;
 
 /** @internal */
-final class UnresolvableType extends LogicException implements Type
+final class UnresolvableType implements Type
 {
-    private string $rawType;
-
-    public function __construct(string $rawType, string $message, ?Throwable $previous = null)
-    {
-        $this->rawType = $rawType;
-
-        parent::__construct($message, 1679578492, $previous);
-    }
+    public function __construct(
+        private string $rawType,
+        private string $message,
+        private ?Throwable $previous = null
+    ) {}
 
     public static function forProperty(string $raw, string $signature, InvalidType $exception): self
     {
@@ -79,14 +76,24 @@ public static function forLocalAlias(string $raw, string $name, ClassType $type,
         );
     }
 
+    public function message(): string
+    {
+        return $this->message;
+    }
+
+    public function previous(): ?Throwable
+    {
+        return $this->previous;
+    }
+
     public function accepts(mixed $value): bool
     {
-        throw $this;
+        throw new LogicException();
     }
 
     public function matches(Type $other): bool
     {
-        throw $this;
+        throw new LogicException();
     }
 
     public function toString(): string

tests/Unit/Definition/Repository/Reflection/ReflectionClassDefinitionRepositoryTest.php

@@ -166,7 +166,7 @@ public function test_invalid_property_type_throws_exception(): void
 
         self::assertInstanceOf(UnresolvableType::class, $type);
         /** @var UnresolvableType $type */
-        self::assertMatchesRegularExpression('/^The type `InvalidType` for property `.*` could not be resolved: .*$/', $type->getMessage());
+        self::assertMatchesRegularExpression('/^The type `InvalidType` for property `.*` could not be resolved: .*$/', $type->message());
     }
 
     public function test_invalid_property_default_value_throws_exception(): void
@@ -180,7 +180,7 @@ public function test_invalid_property_default_value_throws_exception(): void
         $type = $class->properties()->get('propertyWithInvalidDefaultValue')->type();
 
         self::assertInstanceOf(UnresolvableType::class, $type);
-        self::assertMatchesRegularExpression('/Property `.*::\$propertyWithInvalidDefaultValue` of type `string` has invalid default value false/', $type->getMessage());
+        self::assertMatchesRegularExpression('/Property `.*::\$propertyWithInvalidDefaultValue` of type `string` has invalid default value false/', $type->message());
     }
 
     public function test_property_with_non_matching_types_throws_exception(): void
@@ -217,7 +217,7 @@ public function publicMethod($parameterWithInvalidType): void {}
 
         self::assertInstanceOf(UnresolvableType::class, $type);
         /** @var UnresolvableType $type */
-        self::assertMatchesRegularExpression('/^The type `InvalidTypeWithPendingSpaces` for parameter `.*` could not be resolved: .*$/', $type->getMessage());
+        self::assertMatchesRegularExpression('/^The type `InvalidTypeWithPendingSpaces` for parameter `.*` could not be resolved: .*$/', $type->message());
     }
 
     public function test_invalid_method_return_type_throws_exception(): void
@@ -235,7 +235,7 @@ public function publicMethod($parameterWithInvalidType): void {}
 
         self::assertInstanceOf(UnresolvableType::class, $type);
         /** @var UnresolvableType $type */
-        self::assertMatchesRegularExpression('/^The type `InvalidType` for return type of method `.*` could not be resolved: .*$/', $type->getMessage());
+        self::assertMatchesRegularExpression('/^The type `InvalidType` for return type of method `.*` could not be resolved: .*$/', $type->message());
     }
 
     public function test_invalid_parameter_default_value_throws_exception(): void
@@ -252,7 +252,7 @@ public function publicMethod($parameterWithInvalidDefaultValue = false): void {}
         $type = $class->methods()->get('publicMethod')->parameters()->get('parameterWithInvalidDefaultValue')->type();
 
         self::assertInstanceOf(UnresolvableType::class, $type);
-        self::assertMatchesRegularExpression('/Parameter `.*::publicMethod\(\$parameterWithInvalidDefaultValue\)` of type `string` has invalid default value false/', $type->getMessage());
+        self::assertMatchesRegularExpression('/Parameter `.*::publicMethod\(\$parameterWithInvalidDefaultValue\)` of type `string` has invalid default value false/', $type->message());
     }
 
     public function test_parameter_with_non_matching_types_throws_exception(): void

tests/Unit/Type/Types/UnresolvableTypeTest.php

@@ -6,31 +6,25 @@
 
 use CuyZ\Valinor\Tests\Fake\Type\FakeType;
 use CuyZ\Valinor\Type\Types\UnresolvableType;
+use LogicException;
 use PHPUnit\Framework\TestCase;
 
 final class UnresolvableTypeTest extends TestCase
 {
-    public function test_unresolvable_type_has_correct_code(): void
+    public function test_call_unresolvable_type_accepts_throws_exception(): void
     {
         $type = new UnresolvableType('some-type', 'some message');
 
-        self::assertSame(1679578492, $type->getCode());
-    }
-
-    public function test_call_unresolvable_type_accepts_throws_itself(): void
-    {
-        $type = new UnresolvableType('some-type', 'some message');
-
-        $this->expectExceptionObject($type);
+        $this->expectException(LogicException::class);
 
         $type->accepts('foo');
     }
 
-    public function test_call_unresolvable_type_matches_throws_itself(): void
+    public function test_call_unresolvable_type_matches_throws_exception(): void
     {
         $type = new UnresolvableType('some-type', 'some message');
 
-        $this->expectExceptionObject($type);
+        $this->expectException(LogicException::class);
 
         $type->matches(new FakeType());
     }