fix(args): fix variadic args

Fixes: #337
Co-authored-by: Yoram <[email protected]>

Author: Xenira

.github/workflows/build.yml

@@ -84,7 +84,7 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
         php: ["8.0", "8.1", "8.2", "8.3", "8.4"]
         rust: [stable, nightly]
-        clang: ["15", "17"]
+        clang: ["17", "18"]
         phpts: [ts, nts]
         exclude:
           # ext-php-rs requires nightly Rust when on Windows.
@@ -98,9 +98,9 @@ jobs:
           - os: macos-latest
             clang: "17"
           - os: ubuntu-latest
-            clang: "15"
+            clang: "17"
           - os: windows-latest
-            clang: "15"
+            clang: "17"
     env:
       CARGO_TERM_COLOR: always
     steps:
@@ -131,23 +131,20 @@ jobs:
       - name: Cache LLVM and Clang
         id: cache-llvm
         uses: actions/cache@v4
-        # Macos build doesn't work with clang < 18. As a build for version 18 is not available, we skip the setup
-        if: "!contains(matrix.os, 'windows') && !contains(matrix.os, 'macos')"
+        if: "!contains(matrix.os, 'windows')"
         with:
           path: ${{ runner.temp }}/llvm-${{ matrix.clang }}
           key: ${{ matrix.os }}-llvm-${{ matrix.clang }}
       - name: Setup LLVM & Clang
         id: clang
         uses: KyleMayes/install-llvm-action@v2
-        # Macos build doesn't work with clang < 18. As a build for version 18 is not available, we skip the setup
-        if: "!contains(matrix.os, 'windows') && !contains(matrix.os, 'macos')"
+        if: "!contains(matrix.os, 'windows')"
         with:
           version: ${{ matrix.clang }}
           directory: ${{ runner.temp }}/llvm-${{ matrix.clang }}
           cached: ${{ steps.cache-llvm.outputs.cache-hit }}
       - name: Configure Clang
-        # Macos build doesn't work with clang < 18. As a build for version 18 is not available, we skip the setup
-        if: "!contains(matrix.os, 'windows') && !contains(matrix.os, 'macos')"
+        if: "!contains(matrix.os, 'windows')"
         run: |
           echo "LIBCLANG_PATH=${{ runner.temp }}/llvm-${{ matrix.clang }}/lib" >> $GITHUB_ENV
           echo "LLVM_VERSION=${{ steps.clang.outputs.version }}" >> $GITHUB_ENV

crates/macros/src/function.rs

@@ -563,6 +563,10 @@ impl TypedArg<'_> {
             quote! {
                 #name.val().unwrap_or(#default.into())
             }
+        } else if self.variadic {
+            quote! {
+                &#name.variadic_vals()
+            }
         } else if self.nullable {
             // Originally I thought we could just use the below case for `null` options, as
             // `val()` will return `Option<Option<T>>`, however, this isn't the case when

src/args.rs

@@ -250,9 +250,12 @@ impl<'a, 'b> ArgParser<'a, 'b> {
     /// should break execution after seeing an error type.
     pub fn parse(mut self) -> Result<()> {
         let max_num_args = self.args.len();
-        let min_num_args = self.min_num_args.unwrap_or(max_num_args);
+        let mut min_num_args = self.min_num_args.unwrap_or(max_num_args);
         let num_args = self.arg_zvals.len();
         let has_variadic = self.args.last().is_some_and(|arg| arg.variadic);
+        if has_variadic && min_num_args > 0 {
+            min_num_args -= 1;
+        }
 
         if num_args < min_num_args || (!has_variadic && num_args > max_num_args) {
             // SAFETY: Exported C function is safe, return value is unused and parameters

src/types/zval.rs

@@ -719,3 +719,13 @@ impl<'a> FromZvalMut<'a> for &'a mut Zval {
         Some(zval)
     }
 }
+
+impl<'a> FromZvalMut<'a> for &'a [&'a Zval] {
+    const TYPE: DataType = DataType::Array;
+
+    fn from_zval_mut(_zval: &'a mut Zval) -> Option<Self> {
+        unimplemented!(
+            "This impl is currently purely to meet the trait bounds for variadic functions."
+        )
+    }
+}

tests/src/integration/variadic_args.php

@@ -0,0 +1,36 @@
+<?php
+
+require "_utils.php";
+
+$a = 'a';
+$b = 'b';
+$c = 'c';
+
+$array = [$b, 'a','c'];
+
+// Passing arguments as references
+$args = test_variadic_args();
+assert($args === [], 'Expected no arguments to be returned');
+
+$args = test_variadic_args($a);
+assert($args === ['a'], 'Expected to return argument $a');
+
+$args = test_variadic_args($a, $b, $c);
+assert($args === ['a', 'b', 'c'], 'Expected to return arguments $a, $b and $c');
+
+$args = test_variadic_args(...$array);
+assert($args === ['b', 'a', 'c'], 'Expected to return an array with the array $array');
+
+assert_exception_thrown('test_variadic_add_required');
+
+// Values directly passed
+$sum = test_variadic_add_required(1, 2, 3); // 1
+assert($sum === 6, 'Expected to return 6');
+
+$count = test_variadic_add_required(11); // 11
+assert($count === 11, 'Allow only one argument');
+
+$types = test_variadic_args('a', 1, ['abc', 'def', 0.01], true, new stdClass);
+assert(gettype(end($types[2])) === 'double', 'Type of argument 2 and its last element should be a float of 0.01');
+assert($types[3], 'Arg 4 should be boolean true');
+assert($types[4] instanceof stdClass, 'Last argument is an instance of an StdClass');

tests/src/integration/variadic_args.rs

@@ -0,0 +1,4 @@
+#[test]
+fn test_variadic_args() {
+    assert!(crate::integration::run_php("variadic_args.php"));
+}

tests/src/lib.rs

@@ -165,6 +165,22 @@ fn key_to_zval(key: ArrayKey) -> Zval {
     }
 }
 
+// Rust type &[&Zval] must be converted because to Vec<Zval> because of
+// lifetime hell.
+#[php_function]
+pub fn test_variadic_args(params: &[&Zval]) -> Vec<Zval> {
+    params.iter().map(|x| x.shallow_clone()).collect()
+}
+
+#[php_function]
+pub fn test_variadic_add_required(number: u32, numbers: &[&Zval]) -> u32 {
+    number
+        + numbers
+            .iter()
+            .map(|x| x.long().unwrap() as u32)
+            .sum::<u32>()
+}
+
 #[php_class]
 pub struct TestClass {
     string: String,
@@ -233,6 +249,8 @@ pub fn build_module(module: ModuleBuilder) -> ModuleBuilder {
         .function(wrap_function!(iter_back))
         .function(wrap_function!(iter_next_back))
         .function(wrap_function!(test_class))
+        .function(wrap_function!(test_variadic_args))
+        .function(wrap_function!(test_variadic_add_required))
 }
 
 #[cfg(test)]
@@ -304,4 +322,5 @@ mod integration {
     mod object;
     mod string;
     mod types;
+    mod variadic_args;
 }