feat(interfaces): added support for short form of php(implements("\\...")) macro

Author: kakserpom

crates/macros/src/class.rs

@@ -121,10 +121,13 @@ impl ToTokens for ClassEntryAttribute {
             ClassEntryAttribute::Name(name) => {
                 // For a string literal, generate a function that looks up the class at runtime
                 // Uses try_find_no_autoload to avoid triggering autoloading during MINIT
+                // Strip leading backslash since PHP's class table stores names without it
+                // Convert to lowercase since PHP's class table uses lowercase keys
+                let lookup_name = name.strip_prefix('\\').unwrap_or(name).to_lowercase();
                 quote! {
                     (
-                        || ::ext_php_rs::zend::ClassEntry::try_find_no_autoload(#name)
-                            .expect(concat!("Failed to find class entry for ", #name)),
+                        || ::ext_php_rs::zend::ClassEntry::try_find_no_autoload(#lookup_name)
+                            .expect(concat!("Failed to find class entry for ", #lookup_name)),
                         #name
                     )
                 }

src/zend/class.rs

@@ -39,25 +39,32 @@ impl ClassEntry {
     /// triggering autoloading.
     ///
     /// This is useful during module initialization when autoloading might not be
-    /// available or could cause issues.
+    /// available or could cause issues. It uses the compiler globals class table
+    /// which is available during MINIT.
     ///
     /// Returns a reference to the class if found, or [`None`] if the class
     /// could not be found or the class table has not been initialized.
     #[must_use]
     pub fn try_find_no_autoload(name: &str) -> Option<&'static Self> {
-        // ZEND_FETCH_CLASS_NO_AUTOLOAD = 0x80
-        const ZEND_FETCH_CLASS_NO_AUTOLOAD: u32 = 0x80;
+        use crate::types::ZendHashTable;
+        use crate::zend::CompilerGlobals;
 
-        ExecutorGlobals::get().class_table()?;
-        let mut name = ZendStr::new(name, false);
+        let cg = CompilerGlobals::get();
+        let class_table = cg.class_table()?;
 
-        unsafe {
-            crate::ffi::zend_lookup_class_ex(
-                &raw mut *name,
-                ptr::null_mut(),
-                ZEND_FETCH_CLASS_NO_AUTOLOAD,
+        // zend_hash_str_find_ptr_lc handles lowercase conversion internally
+        let ce_ptr = unsafe {
+            crate::ffi::zend_hash_str_find_ptr_lc(
+                ptr::from_ref::<ZendHashTable>(class_table).cast(),
+                name.as_ptr().cast(),
+                name.len(),
             )
-            .as_ref()
+        };
+
+        if ce_ptr.is_null() {
+            None
+        } else {
+            unsafe { (ce_ptr as *const Self).as_ref() }
         }
     }
 

src/zend/globals.rs

@@ -226,6 +226,7 @@ impl ExecutorGlobals {
     }
 }
 
+/// Stores global variables used in the PHP compiler.
 pub type CompilerGlobals = _zend_compiler_globals;
 
 impl CompilerGlobals {
@@ -284,6 +285,15 @@ impl CompilerGlobals {
 
         GlobalWriteGuard { globals, guard }
     }
+
+    /// Attempts to retrieve the global class hash table from compiler globals.
+    ///
+    /// This is useful during module initialization (MINIT) when the executor
+    /// globals class table may not be available yet.
+    #[must_use]
+    pub fn class_table(&self) -> Option<&ZendHashTable> {
+        unsafe { self.class_table.as_ref() }
+    }
 }
 
 /// Stores the SAPI module used in the PHP executor.

src/zend/mod.rs

@@ -38,6 +38,7 @@ pub use ex::ExecuteData;
 pub use exception_observer::{ExceptionInfo, ExceptionObserver};
 pub use function::Function;
 pub use function::FunctionEntry;
+pub use globals::CompilerGlobals;
 pub use globals::ExecutorGlobals;
 pub use globals::FileGlobals;
 pub use globals::ProcessGlobals;

tests/src/integration/interface/interface.php

@@ -166,3 +166,62 @@ function greetWithInterface(ExtPhpRs\Interface\ParentInterface $obj): string {
 
 $result = greetWithInterface($greeter);
 assert($result === 'Hello from World!', 'parentMethod should work via interface type hint');
+
+// ============================================================================
+// Test Feature 5: Short form implements syntax
+// Using #[php(implements("\\InterfaceName"))] instead of verbose form
+// ============================================================================
+
+// Test ArrayAccess implementation using short form
+assert(class_exists('ExtPhpRs\Interface\ShortFormArrayAccess'), 'ShortFormArrayAccess should exist');
+
+$arr = new ExtPhpRs\Interface\ShortFormArrayAccess();
+assert($arr instanceof ArrayAccess, 'ShortFormArrayAccess should implement ArrayAccess');
+
+// Test ArrayAccess methods
+assert(isset($arr[0]), 'offset 0 should exist');
+assert(isset($arr[4]), 'offset 4 should exist');
+assert(!isset($arr[5]), 'offset 5 should not exist');
+assert($arr[0] === 10, 'offset 0 should be 10');
+assert($arr[2] === 30, 'offset 2 should be 30');
+
+$arr[1] = 99;
+assert($arr[1] === 99, 'offset 1 should be 99 after set');
+
+// Test Countable implementation using short form
+assert(class_exists('ExtPhpRs\Interface\CountableTest'), 'CountableTest should exist');
+
+$countable = new ExtPhpRs\Interface\CountableTest();
+assert($countable instanceof Countable, 'CountableTest should implement Countable');
+
+// Test count() function works
+assert(count($countable) === 0, 'Empty CountableTest should have count 0');
+
+$countable->add('one');
+$countable->add('two');
+$countable->add('three');
+assert(count($countable) === 3, 'CountableTest with 3 items should have count 3');
+
+// Test mixed implements syntax (explicit form + short form)
+assert(class_exists('ExtPhpRs\Interface\MixedImplementsTest'), 'MixedImplementsTest should exist');
+
+$mixed = new ExtPhpRs\Interface\MixedImplementsTest();
+assert($mixed instanceof Iterator, 'MixedImplementsTest should implement Iterator (explicit form)');
+assert($mixed instanceof Countable, 'MixedImplementsTest should implement Countable (short form)');
+assert($mixed instanceof Traversable, 'MixedImplementsTest should implement Traversable');
+
+// Test count() works
+assert(count($mixed) === 3, 'MixedImplementsTest should have count 3');
+
+// Test iteration works
+$collected = [];
+foreach ($mixed as $key => $value) {
+    $collected[$key] = $value;
+}
+assert($collected === [0 => 10, 1 => 20, 2 => 30], 'MixedImplementsTest should iterate correctly');
+
+// Test reflection shows both interfaces
+$mixedReflection = new ReflectionClass(ExtPhpRs\Interface\MixedImplementsTest::class);
+$interfaces = $mixedReflection->getInterfaceNames();
+assert(in_array('Iterator', $interfaces), 'Reflection should show Iterator interface');
+assert(in_array('Countable', $interfaces), 'Reflection should show Countable interface');

tests/src/integration/interface/mod.rs

@@ -1,5 +1,5 @@
 use ext_php_rs::prelude::*;
-use ext_php_rs::types::ZendClassObject;
+use ext_php_rs::types::{ZendClassObject, Zval};
 use ext_php_rs::zend::ce;
 
 #[php_interface]
@@ -211,6 +211,144 @@ impl VecIterator {
 // You can use `#[php_impl_interface]` to implement interfaces defined in other crates.
 // See the `php_interface` and `php_impl_interface` macros for more details.
 
+// ============================================================================
+// Test Feature 5: Short form implements syntax
+// Using #[php(implements("\\InterfaceName"))] instead of the verbose
+// #[php(implements(ce = ce::interface, stub = "\\InterfaceName"))]
+// ============================================================================
+
+/// Test class implementing `ArrayAccess` using short form syntax.
+/// This tests runtime class entry lookup via `ClassEntry::try_find_no_autoload()`.
+#[php_class]
+#[php(name = "ExtPhpRs\\Interface\\ShortFormArrayAccess")]
+#[php(implements("\\ArrayAccess"))]
+pub struct ShortFormArrayAccess {
+    data: Vec<i64>,
+}
+
+#[php_impl]
+#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+impl ShortFormArrayAccess {
+    pub fn __construct() -> Self {
+        Self {
+            data: vec![10, 20, 30, 40, 50],
+        }
+    }
+
+    /// `ArrayAccess::offsetExists` - offset must be `mixed` to match PHP interface.
+    pub fn offset_exists(&self, offset: &Zval) -> bool {
+        if let Some(idx) = offset.long() {
+            idx >= 0 && (idx as usize) < self.data.len()
+        } else {
+            false
+        }
+    }
+
+    /// `ArrayAccess::offsetGet` - offset must be `mixed` to match PHP interface.
+    pub fn offset_get(&self, offset: &Zval) -> Option<i64> {
+        let idx = offset.long()?;
+        if idx >= 0 {
+            self.data.get(idx as usize).copied()
+        } else {
+            None
+        }
+    }
+
+    /// `ArrayAccess::offsetSet` - offset and value must be `mixed` to match PHP interface.
+    pub fn offset_set(&mut self, offset: &Zval, value: &Zval) {
+        if let (Some(idx), Some(val)) = (offset.long(), value.long())
+            && idx >= 0
+            && (idx as usize) < self.data.len()
+        {
+            self.data[idx as usize] = val;
+        }
+    }
+
+    /// `ArrayAccess::offsetUnset` - offset must be `mixed` to match PHP interface.
+    pub fn offset_unset(&mut self, offset: &Zval) {
+        if let Some(idx) = offset.long()
+            && idx >= 0
+            && (idx as usize) < self.data.len()
+        {
+            self.data.remove(idx as usize);
+        }
+    }
+}
+
+/// Test class implementing `Countable` using short form syntax.
+/// `Countable` is defined in SPL which is always available.
+#[php_class]
+#[php(name = "ExtPhpRs\\Interface\\CountableTest")]
+#[php(implements("\\Countable"))]
+pub struct CountableTest {
+    items: Vec<String>,
+}
+
+#[php_impl]
+#[allow(clippy::cast_possible_wrap)]
+impl CountableTest {
+    pub fn __construct() -> Self {
+        Self { items: Vec::new() }
+    }
+
+    pub fn add(&mut self, item: String) {
+        self.items.push(item);
+    }
+
+    /// Returns the count for `count()`.
+    pub fn count(&self) -> i64 {
+        self.items.len() as i64
+    }
+}
+
+/// Test class implementing multiple interfaces using mixed syntax
+/// (both short form and explicit form).
+#[php_class]
+#[php(name = "ExtPhpRs\\Interface\\MixedImplementsTest")]
+#[php(implements(ce = ce::iterator, stub = "\\Iterator"))]
+#[php(implements("\\Countable"))]
+pub struct MixedImplementsTest {
+    items: Vec<i64>,
+    index: usize,
+}
+
+#[php_impl]
+impl MixedImplementsTest {
+    pub fn __construct() -> Self {
+        Self {
+            items: vec![10, 20, 30],
+            index: 0,
+        }
+    }
+
+    // Iterator methods
+    pub fn current(&self) -> Option<i64> {
+        self.items.get(self.index).copied()
+    }
+
+    pub fn key(&self) -> usize {
+        self.index
+    }
+
+    pub fn next(&mut self) {
+        self.index += 1;
+    }
+
+    pub fn rewind(&mut self) {
+        self.index = 0;
+    }
+
+    pub fn valid(&self) -> bool {
+        self.index < self.items.len()
+    }
+
+    #[allow(clippy::cast_possible_wrap)]
+    // Countable method
+    pub fn count(&self) -> i64 {
+        self.items.len() as i64
+    }
+}
+
 // Test Feature 2: Interface inheritance via trait bounds
 // Define a parent interface
 #[php_interface]
@@ -270,6 +408,10 @@ pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
         .class::<VecIterator>()
         // Greeter with #[php_impl_interface]
         .class::<Greeter>()
+        // Short form implements syntax tests
+        .class::<ShortFormArrayAccess>()
+        .class::<CountableTest>()
+        .class::<MixedImplementsTest>()
 }
 
 #[cfg(test)]