Adding support for Closure in constant expressions

Author: nyamsprod

docs/9.0/reader/record-mapping.md

@@ -713,6 +713,35 @@ Serializer\Denormalizer::unregisterAllAliases();
 
 <p class="message-info">If needed, can use the <code>Denormalizer::unregisterAll</code> to unregister all callbacks (alias and types)</p>
 
+#### Register a callback directly
+
+<p class="message-info">new in version <code>9.29</code></p>
+
+You can directly register a callback if you are using `PHP8.5+` prior to this version the code will throw an error since using
+a static closure on attribute is not yet valid.
+
+Once your code is migrated to the correct PHP version you can write the following:
+
+```php
+use App\Domain\Money
+use League\Csv\Serializer;
+
+#[Serializer\MapCell(
+    column: 'amount', 
+    cast: static function (mixed $value): int { 
+        return 42; 
+    }
+)]    
+private ?int $amount;
+```
+
+This will result in the same mapping as the previous example using the alias. But you no longer have to register the `alias` yourself as 
+this is taking care of by the engine itself. 
+
+<p class="message-notice">Of note, if you want to re-use multiple time registering the callback casting using an
+explicit <code>alias</code> will always be the recommended way.</p>
+
+
 ### Implementing a TypeCasting class
 
 If you need to support `Intersection` type you need to provide your own class to typecast the value according

src/Serializer/CallbackCasting.php

@@ -49,7 +49,7 @@ public function __construct(
         ReflectionProperty|ReflectionParameter $reflectionProperty,
         private readonly ?string $alias = null
     ) {
-        [$this->type, $this->isNullable] = self::resolve($reflectionProperty);
+        [$this->type, $this->isNullable] = self::resolve($reflectionProperty, $alias);
 
         $this->message = match (true) {
             $reflectionProperty instanceof ReflectionParameter => 'The method `'.$reflectionProperty->getDeclaringClass()?->getName().'::'.$reflectionProperty->getDeclaringFunction()->getName().'` argument `'.$reflectionProperty->getName().'` must be typed with a supported type.',
@@ -251,7 +251,11 @@ public static function supports(ReflectionParameter|ReflectionProperty $reflecti
                 continue;
             }
 
-            if (self::aliasSupportsType($type) || (Type::Mixed->value === $type && self::supportsAlias($alias))) {
+            if (
+                self::aliasSupportsType($type) ||
+                (Type::Mixed->value === $type && self::supportsAlias($alias))
+                || isset(self::$aliases[Type::Mixed->value][$alias])
+            ) {
                 return true;
             }
         }
@@ -324,7 +328,7 @@ private static function resolveAliasCallback(string $type, string $alias): Closu
      *
      * @return array{0:string, 1:bool}
      */
-    private static function resolve(ReflectionParameter|ReflectionProperty $reflectionProperty): array
+    private static function resolve(ReflectionParameter|ReflectionProperty $reflectionProperty, ?string $alias = null): array
     {
         if (null === $reflectionProperty->getType()) {
             return [Type::Mixed->value, true];
@@ -334,7 +338,8 @@ private static function resolve(ReflectionParameter|ReflectionProperty $reflecti
 
         $type = null;
         $isNullable = false;
-        $hasMixed = false;
+        $hasMixed = null !== $alias && isset(self::$aliases[Type::Mixed->value][$alias]);
+
         foreach ($types as $foundType) {
             if (!$isNullable && $foundType->allowsNull()) {
                 $isNullable = true;

src/Serializer/Denormalizer.php

@@ -29,6 +29,7 @@
 use function array_values;
 use function count;
 use function is_int;
+use function str_replace;
 
 final class Denormalizer
 {
@@ -434,12 +435,24 @@ private function resolveTypeCasting(ReflectionProperty|ReflectionParameter $refl
 
     public function resolveTypeCaster(MapCell $mapCell, ReflectionMethod|ReflectionProperty $accessor): ?string
     {
-        /** @var ?class-string<TypeCasting> $typeCaster */
+        /** @var class-string<TypeCasting>|Closure|null $typeCaster */
         $typeCaster = $mapCell->cast;
         if (null === $typeCaster) {
             return null;
         }
 
+        if ($typeCaster instanceof Closure) {
+            $name = $accessor->getName();
+            if ($accessor instanceof ReflectionMethod) {
+                $name .= '_'.$accessor->getParameters()[0]->getName();
+            }
+
+            $alias = '@_league_csv_generated_'.str_replace('\\', '_', $this->class->getName()).'__'.$name;
+            Denormalizer::registerAlias($alias, Type::Mixed->value, $typeCaster);
+
+            return CallbackCasting::class.$alias;
+        }
+
         if (class_exists($typeCaster)) {
             if (!(new ReflectionClass($typeCaster))->implementsInterface(TypeCasting::class)) {
                 throw MappingFailed::dueToInvalidTypeCastingClass($typeCaster);
@@ -452,9 +465,7 @@ public function resolveTypeCaster(MapCell $mapCell, ReflectionMethod|ReflectionP
             $accessor = $accessor->getParameters()[0];
         }
 
-        if (!CallbackCasting::supports($accessor, $typeCaster)) {
-            throw MappingFailed::dueToInvalidTypeCastingClass($typeCaster);
-        }
+        CallbackCasting::supports($accessor, $typeCaster) || throw MappingFailed::dueToInvalidTypeCastingClass($typeCaster);
 
         return CallbackCasting::class.$typeCaster;
     }

src/Serializer/MapCell.php

@@ -14,16 +14,17 @@
 namespace League\Csv\Serializer;
 
 use Attribute;
+use Closure;
 
 #[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_PROPERTY)]
 final readonly class MapCell
 {
     /**
-     * @param class-string|string|null $cast
+     * @param Closure|class-string|string|null $cast
      */
     public function __construct(
         public string|int|null $column = null,
-        public ?string $cast = null,
+        public Closure|string|null $cast = null,
         public array $options = [],
         public bool $ignore = false,
         public ?bool $convertEmptyStringToNull = null,