Refactor CallableWrapper and CallableWrapperTest for improved type validation; enhance error messages for better clarity

Author: rcalicdan

src/Wrapper/CallableWrapper.php

@@ -35,12 +35,10 @@ public static function wrap(string $function, string $paramName, mixed $callable
 
         $prefix = ($paramName === 'return') ? "$function(): Return value" : "$function(): Callback \$$paramName";
 
-        // 1. Single Callable
         if (\is_callable($callable)) {
             return self::wrapTypeNode($typeNode, $callable, $prefix, $registry);
         }
 
-        // 2. Collections of Callables (e.g. list<callable(...)> or callable[])
         if (\is_array($callable) && $typeNode !== null) {
             $innerCallableTypeNode = null;
 
@@ -116,18 +114,21 @@ private static function enforceClosureConstraints(string $identifierName, mixed
     }
 
     /**
-     * Validates variadic and positional arguments passed into an intercepted callback.
+     * Validates variadic, positional, and named arguments passed into an intercepted callback.
      *
      * @param array<int|string, mixed> $args
      */
     private static function validateCallbackArguments(CallableTypeNode $typeNode, array $args, string $prefix, TypeValidatorRegistry $registry): void
     {
-        $argCount = \count($args);
+        $argValues = array_values($args);
+        $argCount = \count($argValues);
 
         foreach ($typeNode->parameters as $index => $paramNode) {
+            $rawParamName = ltrim($paramNode->parameterName ?? '', '$');
+
             if ($paramNode->isVariadic) {
                 for ($vIdx = $index; $vIdx < $argCount; $vIdx++) {
-                    $err = $registry->validate($args[$vIdx], $paramNode->type, "$prefix variadic argument #" . ($vIdx + 1));
+                    $err = $registry->validate($argValues[$vIdx], $paramNode->type, "$prefix variadic argument #" . ($vIdx + 1));
                     if ($err !== null) {
                         throw ErrorFactory::prepareException(new TypePHPTypeError($err->getMessage()));
                     }
@@ -136,12 +137,24 @@ private static function validateCallbackArguments(CallableTypeNode $typeNode, ar
                 break;
             }
 
-            if (\array_key_exists($index, $args)) {
-                $err = $registry->validate($args[$index], $paramNode->type, "$prefix argument #" . ($index + 1));
+            $val = null;
+            $hasVal = false;
+
+            if ($rawParamName !== '' && \array_key_exists($rawParamName, $args)) {
+                $val = $args[$rawParamName];
+                $hasVal = true;
+            } elseif (\array_key_exists($index, $argValues)) {
+                $val = $argValues[$index];
+                $hasVal = true;
+            }
+
+            if ($hasVal) {
+                $argLabel = $rawParamName !== '' ? "\$$rawParamName" : ('argument #' . ($index + 1));
+                $err = $registry->validate($val, $paramNode->type, "$prefix $argLabel");
                 if ($err !== null) {
                     throw ErrorFactory::prepareException(new TypePHPTypeError($err->getMessage()));
                 }
             }
         }
     }
-}
+}

src/Wrapper/IterableWrapper.php

@@ -137,4 +137,4 @@ private static function wrapGenerator(iterable $iterable, \Closure $typeCheckCal
             yield $key => $value;
         }
     }
-}
+}

tests/Fixtures/Services/InvokableFormatterService.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypePHP\Tests\Fixtures\Services;
+
+class InvokableFormatterService
+{
+    public function __invoke(int $id): string
+    {
+        if ($id <= 0) {
+            return ''; // Violates non-empty-string
+        }
+
+        return "invoked_{$id}";
+    }
+}

tests/TypeChecking/Boundaries/AdvancedEdgeCasesTest.php

@@ -30,7 +30,8 @@ function processFormatterList(array $formatters, int $id): array
             [$id, , $username] = [10, 'skipped_token', 'Alice'];
 
             expect($id)->toBe(10)
-                ->and($username)->toBe('Alice');
+                ->and($username)->toBe('Alice')
+            ;
 
             expect(function () {
                 /**
@@ -51,15 +52,16 @@ function processFormatterList(array $formatters, int $id): array
 
             expect($id)->toBe(42)
                 ->and($street)->toBe('Broadway')
-                ->and($zip)->toBe(90210);
+                ->and($zip)->toBe(90210)
+            ;
 
             expect(function () {
                 /**
                  * @var positive-int $id
                  * @var non-empty-string $street
                  * @var int<10000, 99999> $zip
                  */
-                [$id, [$street, $zip]] = [42, ['', 90210]]; 
+                [$id, [$street, $zip]] = [42, ['', 90210]];
             })->toThrow(TypeError::class, 'Variable $street must be of type non-empty-string');
         });
     });
@@ -74,15 +76,17 @@ function processFormatterList(array $formatters, int $id): array
             $collection->add(20);
 
             expect($collection->count())->toBe(3)
-                ->and($collection->toArray())->toBe([10, null, 20]);
+                ->and($collection->toArray())->toBe([10, null, 20])
+            ;
         });
 
         test('throws TypeError when adding invalid scalar to Collection<?positive-int>', function () {
             /** @var GenericCollection<?positive-int> $collection */
             $collection = new GenericCollection();
 
             expect(fn () => $collection->add(-50))
-                ->toThrow(TypeError::class, 'Argument $item (template T = ?positive-int) must be of type positive-int, negative int (-50) given');
+                ->toThrow(TypeError::class, 'Argument $item (template T = ?positive-int) must be of type positive-int, negative int (-50) given')
+            ;
         });
     });
 
@@ -100,11 +104,12 @@ function processFormatterList(array $formatters, int $id): array
         test('throws TypeError when a callable in the collection returns an invalid type', function () {
             $formatters = [
                 fn (int $id): string => "id_{$id}",
-                fn (int $id): string => '', 
+                fn (int $id): string => '',
             ];
 
             expect(fn () => processFormatterList($formatters, 42))
-                ->toThrow(TypeError::class, 'Callback $formatters[1] return value must be of type non-empty-string');
+                ->toThrow(TypeError::class, 'Callback $formatters[1] return value must be of type non-empty-string')
+            ;
         });
     });
-});
+});