Improve alias usage with dernormalization

src/Serializer/AfterMapping.php

@@ -16,8 +16,6 @@
 use Attribute;
 use ReflectionAttribute;
 use ReflectionClass;
-use ReflectionException;
-use ReflectionMethod;
 
 /**
  * @deprecated since version 9.17.0
@@ -27,36 +25,13 @@
 #[Attribute(Attribute::TARGET_CLASS)]
 final class AfterMapping
 {
-    /** @var array<string> $methods */
+    public readonly MapRecord $mapRecord;
     public readonly array $methods;
 
     public function __construct(string ...$methods)
     {
-        $this->methods = $methods;
-    }
-
-    /**
-     *
-     * @return array<ReflectionMethod>
-     */
-    public function afterMappingMethods(ReflectionClass $class): array
-    {
-        $methods = [];
-        foreach ($this->methods as $method) {
-            try {
-                $accessor = $class->getMethod($method);
-            } catch (ReflectionException $exception) {
-                throw new MappingFailed('The method `'.$method.'` is not defined on the `'.$class->getName().'` class.', 0, $exception);
-            }
-
-            if (0 !== $accessor->getNumberOfRequiredParameters()) {
-                throw new MappingFailed('The method `'.$class->getName().'::'.$accessor->getName().'` has too many required parameters.');
-            }
-
-            $methods[] = $accessor;
-        }
-
-        return $methods;
+        $this->mapRecord = new MapRecord($methods);
+        $this->methods = $this->mapRecord->afterMapping;
     }
 
     public static function from(ReflectionClass $class): ?self

src/Serializer/CallbackCasting.php

@@ -86,11 +86,30 @@ public function setOptions(
         }
 
         /** @var Closure $callback */
-        $callback = self::$aliases[$this->type][$this->alias];
+        $callback = self::resolveAliasCallback($this->type);
         $this->callback = $callback;
         $this->options = $options;
     }
 
+    private static function resolveAliasCallback(string $type): Closure
+    {
+        foreach (self::aliases() as $alias => $registeredType) {
+            if ($type === $registeredType) {
+                return self::$aliases[$registeredType][$alias];
+            }
+
+            try {
+                $reflType = new ReflectionClass($type); /* @phpstan-ignore-line */
+                if ($reflType->implementsInterface($registeredType)) {
+                    return self::$aliases[$registeredType][$alias];
+                }
+            } catch (Throwable) {
+            }
+        }
+
+        throw new MappingFailed('The `'.$type.'` could not be resolved.');
+    }
+
     /**
      * @return TValue
      */
@@ -239,17 +258,32 @@ public static function supports(ReflectionParameter|ReflectionProperty $reflecti
 
         foreach ($propertyTypeList as $propertyType) {
             $type = $propertyType->getName();
-            if (null === $alias) {
-                if (self::supportsType($type)) {
-                    return true;
-                }
+            if (null === $alias && self::supportsType($type)) {
+                return true;
+            }
 
-                continue;
+            if (self::isAliasValid($type) || (Type::Mixed->value === $type && self::supportsAlias($alias))) {
+                return true;
             }
+        }
+
+        return false;
+    }
 
-            if ((self::aliases()[$alias] ?? null) === $type || (Type::Mixed->value === $type && self::supportsAlias($alias))) {
+    private static function isAliasValid(string $type): bool
+    {
+        foreach (self::aliases() as $alias => $registeredType) {
+            if ($type === $registeredType) {
                 return true;
             }
+
+            try {
+                $reflType = new ReflectionClass($type);  /* @phpstan-ignore-line */
+                if ($reflType->implementsInterface($registeredType)) {
+                    return true;
+                }
+            } catch (Throwable) {
+            }
         }
 
         return false;
@@ -277,7 +311,6 @@ private static function resolveSupportedType(string $type): Closure
         throw new MappingFailed('The `'.$type.'` could not be resolved.');
     }
 
-
     /**
      * @throws MappingFailed
      *

src/Serializer/Denormalizer.php

@@ -254,7 +254,7 @@ private function setPropertySetters(array $propertyNames): array
     private function setAfterMappingCalls(): array
     {
         return $this->mapRecord?->afterMappingMethods($this->class)
-            ?? AfterMapping::from($this->class)?->afterMappingMethods($this->class) /* @phpstan-ignore-line */
+            ?? AfterMapping::from($this->class)?->mapRecord->afterMappingMethods($this->class) /* @phpstan-ignore-line */
             ?? [];
     }
 

src/Serializer/DenormalizerTest.php

@@ -27,6 +27,16 @@
 
 final class DenormalizerTest extends TestCase
 {
+    protected function setUp(): void
+    {
+        Denormalizer::unregisterAll();
+    }
+
+    protected function tearDown(): void
+    {
+        Denormalizer::unregisterAll();
+    }
+
     public function testItConvertsAnIterableListOfRecords(): void
     {
         $records = [
@@ -601,7 +611,6 @@ public function __construct(
         };
 
         $instance = Denormalizer::assign($class::class, ['place' => 'YaMouSSokro']);
-
         self::assertInstanceOf($class::class, $instance);
         self::assertSame('yamoussokro', $instance->str);
     }