fix(compiler): validate dynamic call argument counts

src/Generator/ClosureGenerator.php

@@ -150,19 +150,9 @@ trait ClosureGenerator
             }
             $requiredArgCount++;
         }
-        if ($requiredArgCount > 0) {
+
-            $expected = $requiredArgCount === count($params) ? 'exactly' : 'at least';
+        $hasVariadic = $params !== [] && $params[array_key_last($params)]->variadic;
-            $message = $this->genCharPtr(
+        $code .= ParameterCountCheckGenerator::generate($requiredArgCount, count($params), $hasVariadic);
-                'Too few arguments to function {closure}(), %u passed and ' . $expected . ' ' . $requiredArgCount . ' expected',
-                true
-            );
-            $code .= $this->getIndent() . 'if (UNEXPECTED(php::getCallArgNum() < ' . $requiredArgCount . ')) {' . PHP_EOL;
-            $this->indentLevel++;
-            $code .= $this->getIndent() . 'php::throwExceptionEx(zend_ce_argument_count_error, 0, ' . $message . ', php::getCallArgNum());' . PHP_EOL;
-            $code .= $this->getIndent() . 'return php::null;' . PHP_EOL;
-            $this->indentLevel--;
-            $code .= $this->getIndent() . '}' . PHP_EOL;
-        }
 
         foreach ($params as $i => $param) {
             if ($param->byRef) {

src/Generator/ParameterCountCheckGenerator.php

@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace TypePhp\Generator;
+
+final class ParameterCountCheckGenerator
+{
+    /**
+     * Generate the runtime check used at a Zend-to-TypePHP call boundary.
+     *
+     * TypePHP requires dynamic calls to obey the same argument-count rules as
+     * statically resolved calls. This also keeps the generated internal-function
+     * arginfo consistent with what its wrapper accepts.
+     *
+     * This intentionally calls Zend's count-error helper directly. A bare
+     * ZEND_PARSE_PARAMETERS_START/END pair is invalid because ZPP expects every
+     * declared parameter to be consumed by a Z_PARAM_* macro and asserts on
+     * optional signatures.
+     */
+    public static function generate(int $requiredArgCount, int $declaredArgCount, bool $variadic): string
+    {
+        $invalidCountChecks = [];
+        if ($requiredArgCount > 0) {
+            $invalidCountChecks[] = 'php::getCallArgNum() < ' . $requiredArgCount;
+        }
+        if (!$variadic) {
+            $invalidCountChecks[] = 'php::getCallArgNum() > ' . $declaredArgCount;
+        }
+        if ($invalidCountChecks === []) {
+            return '';
+        }
+
+        $invalidCountCheck = implode(' || ', $invalidCountChecks);
+        $maxArgCount = $variadic ? '(uint32_t) -1' : (string) $declaredArgCount;
+
+        return sprintf(<<<'CPP'
+            if (UNEXPECTED(%3$s)) {
+                zend_wrong_parameters_count_error(%1$d, %2$s);
+                php::throwErrorIfOccurred();
+            }
+CPP, $requiredArgCount, $maxArgCount, $invalidCountCheck);
+    }
+}

src/Translator.php

@@ -35,6 +35,7 @@ use TypePhp\Exception\Skip;
 use TypePhp\Exception\SyntaxError;
 use TypePhp\Generator\DefaultArgumentGenerator;
 use TypePhp\Generator\LibraryImportStubGenerator;
+use TypePhp\Generator\ParameterCountCheckGenerator;
 use TypePhp\Generator\Symbol;
 use TypePhp\Metadata\Constants;
 use TypePhp\Platform\PlatformFactory;
@@ -3366,11 +3367,14 @@ CODE;
         // returns with EG(exception) set. Convert back to normal Zend exception
         // propagation at the outermost wrapper.
         $cppCode = 'try {' . PHP_EOL;
-        $callParams = '';
-        if ($functionDef->argCountRequired > 0) {
-            $cppCode .= $this->genWrapperRequiredArgCountCheck($functionDef, $displayName);
-        }
 
+        $cppCode .= ParameterCountCheckGenerator::generate(
+            $functionDef->argCountRequired,
+            count($functionDef->argInfoList),
+            $functionDef->hasVariadicArg(),
+        );
+
+        $callParams = '';
         foreach ($functionDef->argInfoList as $k => $argInfo) {
             $var = 'arg_' . $argInfo->name;
             if ($argInfo->variadic) {
@@ -3498,25 +3502,6 @@ CODE;
         ], true);
     }
 
-    private function genWrapperRequiredArgCountCheck(FunctionDef $functionDef, string $displayName): string
-    {
-        $required = $functionDef->argCountRequired;
-        $expected = $required === count($functionDef->argInfoList) ? 'exactly' : 'at least';
-        $message = $this->genCharPtr(
-            'Too few arguments to function ' . $displayName . '(), %u passed and ' . $expected . ' ' . $required . ' expected',
-            true
-        );
-
-        $code = $this->getIndent() . 'if (UNEXPECTED(php::getCallArgNum() < ' . $required . ')) {' . PHP_EOL;
-        $this->indentLevel++;
-        $code .= $this->getIndent() . 'php::throwExceptionEx(zend_ce_argument_count_error, 0, ' . $message . ', php::getCallArgNum());' . PHP_EOL;
-        $code .= $this->getIndent() . 'return;' . PHP_EOL;
-        $this->indentLevel--;
-        $code .= $this->getIndent() . '}' . PHP_EOL;
-
-        return $code;
-    }
-
     protected function genMethodWrapper(ClassDef $classDef, MethodDef $methodDef): string
     {
         $name = $classDef->getNamespacedName();

tests/compiler/arrow_fn/003.phpt

@@ -12,7 +12,7 @@ function test_basic_arrow() {
 // Test arrow function with multiple parameters
 function test_multi_param_arrow() {
     $pairs = [[1, 2], [3, 4], [5, 6]];
-    $sums = array_map(fn($a, $b) => $a + $b, ...$pairs);
+    $sums = array_map(fn($a, $b, $_unused) => $a + $b, ...$pairs);
     return $sums;
 }
 

tests/compiler/callable/dynamic-method-lexical-scope.phpt

@@ -5,7 +5,7 @@ Dynamic method calls use the declaring class scope
 
 class DynamicScopeBase
 {
-    private function privateValue(): string
+    private function privateValue(mixed $_unused = null): string
     {
         return 'base-private';
     }

tests/compiler/closure/closure-param-defaults.phpt

@@ -48,6 +48,6 @@ array(3) {
   NULL
 }
 string(18) "ArgumentCountError"
-string(74) "Too few arguments to function {closure}(), 0 passed and exactly 1 expected"
+string(57) "stdClass::{closure}() expects exactly 1 argument, 0 given"
 string(18) "ArgumentCountError"
-string(75) "Too few arguments to function {closure}(), 0 passed and at least 1 expected"
+string(58) "stdClass::{closure}() expects at least 1 argument, 0 given"

tests/compiler/functions/args-count.phpt

@@ -0,0 +1,122 @@
+--TEST--
+Zend wrappers validate required, optional, variadic and excessive arguments
+--FILE--
+<?php
+declare(strict_types=1);
+function noArgs() {
+    echo "noArgs\n";
+}
+
+function hello(string $value) {
+    echo "hello:$value\n";
+}
+
+class Greeter {
+    public function hello(string $value, string $suffix = '!'): void {
+        echo "method:$value$suffix\n";
+    }
+
+    public static function staticHello(string $value): void {}
+}
+
+function world(callable $callback) {
+    $callback('a');
+}
+
+function variadic(string $value, ...$results) {
+    var_dump($value, $results);
+}
+
+function main()
+{
+    try {
+        $noArgs = 'noArgs';
+        $noArgs('extra');
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $hello = 'hello';
+        $hello('value', 'extra');
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    $noArgsClosure = static function (): void {
+        echo "closure\n";
+    };
+    try {
+        $noArgsClosure('closure-extra');
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $callback = 'hello';
+        $callback();
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $method = [new Greeter(), 'hello'];
+        $method();
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $method('value', '!', 'extra');
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $staticMethod = [Greeter::class, 'staticHello'];
+        $staticMethod();
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        world(function(string $value, string $value1) {
+
+        });
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        $callable = "variadic";
+        $callable();
+    } catch (ArgumentCountError $e) {
+        var_dump($e->getMessage());
+    }
+
+    $callable('1', 1, 2, 3, 4, 5);
+}
+?>
+--EXPECT--
+string(45) "noArgs() expects exactly 0 arguments, 1 given"
+string(43) "hello() expects exactly 1 argument, 2 given"
+string(58) "stdClass::{closure}() expects exactly 0 arguments, 1 given"
+string(43) "hello() expects exactly 1 argument, 0 given"
+string(53) "Greeter::hello() expects at least 1 argument, 0 given"
+string(53) "Greeter::hello() expects at most 2 arguments, 3 given"
+string(58) "Greeter::staticHello() expects exactly 1 argument, 0 given"
+string(58) "stdClass::{closure}() expects exactly 2 arguments, 1 given"
+string(47) "variadic() expects at least 1 argument, 0 given"
+string(1) "1"
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}

tests/compiler/type_decl/nullable-required-param-check.phpt

@@ -33,6 +33,6 @@ function main(): void
 ?>
 --EXPECT--
 string(18) "ArgumentCountError"
-string(84) "Too few arguments to function expect_nullable_int(), 0 passed and exactly 1 expected"
+string(57) "expect_nullable_int() expects exactly 1 argument, 0 given"
 string(18) "ArgumentCountError"
-string(94) "Too few arguments to function expect_nullable_with_default(), 0 passed and at least 1 expected"
+string(67) "expect_nullable_with_default() expects at least 1 argument, 0 given"