fix(macro): reference mutability inside Option #515

Author: kakserpom

crates/macros/src/function.rs

@@ -540,9 +540,11 @@ impl<'a> Args<'a> {
                                 .and_then(|ga| match ga {
                                     GenericArgument::Type(ty) => Some(match ty {
                                         Type::Reference(r) => {
+                                            // Only mark as_ref for mutable references
+                                            // (Option<&mut T>), not immutable ones (Option<&T>)
+                                            as_ref = r.mutability.is_some();
                                             let mut new_ref = r.clone();
                                             new_ref.mutability = None;
-                                            as_ref = true;
                                             Type::Reference(new_ref)
                                         }
                                         _ => ty.clone(),

src/types/array/mod.rs

@@ -5,7 +5,7 @@ use std::{convert::TryFrom, ffi::CString, fmt::Debug, ptr};
 
 use crate::{
     boxed::{ZBox, ZBoxable},
-    convert::{FromZval, IntoZval},
+    convert::{FromZval, FromZvalMut, IntoZval},
     error::Result,
     ffi::zend_ulong,
     ffi::{
@@ -711,3 +711,11 @@ impl<'a> FromZval<'a> for &'a ZendHashTable {
         zval.array()
     }
 }
+
+impl<'a> FromZvalMut<'a> for &'a mut ZendHashTable {
+    const TYPE: DataType = DataType::Array;
+
+    fn from_zval_mut(zval: &'a mut Zval) -> Option<Self> {
+        zval.array_mut()
+    }
+}

tests/src/integration/array/array.php

@@ -79,3 +79,17 @@
 
 assert(array_key_exists('00', $leading_zeros), '"00" should stay as string key');
 assert($leading_zeros['00'] === 'zerozero', 'Value at key "00" should be "zerozero"');
+
+// Test Option<&ZendHashTable> with literal array (issue #515)
+// This should work without "could not be passed by reference" error
+assert(test_optional_array_ref([1, 2, 3]) === 3, 'Option<&ZendHashTable> should accept literal array');
+assert(test_optional_array_ref(null) === -1, 'Option<&ZendHashTable> should accept null');
+$arr = ['a', 'b', 'c', 'd'];
+assert(test_optional_array_ref($arr) === 4, 'Option<&ZendHashTable> should accept variable array');
+
+// Test Option<&mut ZendHashTable> (anti-regression for issue #515)
+$mut_arr = ['x', 'y'];
+assert(test_optional_array_mut_ref($mut_arr) === 3, 'Option<&mut ZendHashTable> should accept variable array and add element');
+assert(array_key_exists('added_by_rust', $mut_arr), 'Rust should have added a key to the array');
+assert($mut_arr['added_by_rust'] === 'value', 'Added value should be correct');
+assert(test_optional_array_mut_ref(null) === -1, 'Option<&mut ZendHashTable> should accept null');

tests/src/integration/array/mod.rs

@@ -5,7 +5,7 @@ use ext_php_rs::{
     ffi::HashTable,
     php_function,
     prelude::ModuleBuilder,
-    types::{ArrayKey, Zval},
+    types::{ArrayKey, ZendHashTable, Zval},
     wrap_function,
 };
 
@@ -41,13 +41,34 @@ pub fn test_array_keys() -> Zval {
     ht.into_zval(false).unwrap()
 }
 
+/// Test that `Option<&ZendHashTable>` can accept literal arrays (issue #515)
+#[php_function]
+pub fn test_optional_array_ref(arr: Option<&ZendHashTable>) -> i64 {
+    arr.map_or(-1, |ht| i64::try_from(ht.len()).unwrap_or(i64::MAX))
+}
+
+/// Test that `Option<&mut ZendHashTable>` works correctly (anti-regression for issue #515)
+#[php_function]
+pub fn test_optional_array_mut_ref(arr: Option<&mut ZendHashTable>) -> i64 {
+    match arr {
+        Some(ht) => {
+            // Add an element to verify mutation works
+            ht.insert("added_by_rust", "value").ok();
+            i64::try_from(ht.len()).unwrap_or(i64::MAX)
+        }
+        None => -1,
+    }
+}
+
 pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
     builder
         .function(wrap_function!(test_array))
         .function(wrap_function!(test_array_assoc))
         .function(wrap_function!(test_array_assoc_array_keys))
         .function(wrap_function!(test_btree_map))
         .function(wrap_function!(test_array_keys))
+        .function(wrap_function!(test_optional_array_ref))
+        .function(wrap_function!(test_optional_array_mut_ref))
 }
 
 #[cfg(test)]