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

Author: kakserpom

crates/macros/src/class.rs

@@ -30,8 +30,9 @@ pub struct StructAttributes {
     attrs: Vec<Attribute>,
 }
 
-/// Represents a class entry reference, either explicit (with `ce` and `stub`)
-/// or a simple type reference to a Rust type implementing `RegisteredClass`.
+/// Represents a class entry reference, either explicit (with `ce` and `stub`),
+/// a simple type reference to a Rust type implementing `RegisteredClass`,
+/// or a string literal for runtime class lookup.
 ///
 /// # Examples
 ///
@@ -44,13 +45,20 @@ pub struct StructAttributes {
 /// ```ignore
 /// #[php(extends(Base))]
 /// ```
+///
+/// String literal form (for runtime class lookup):
+/// ```ignore
+/// #[php(implements("\\JsonSerializable"))]
+/// ```
 #[derive(Debug)]
 pub enum ClassEntryAttribute {
     /// Explicit class entry with a function returning `&'static ClassEntry` and
     /// a stub name
     Explicit { ce: syn::Expr, stub: String },
     /// A Rust type that implements `RegisteredClass`
     Type(syn::Path),
+    /// A PHP class name to be looked up at runtime via `ClassEntry::try_find`
+    Name(String),
 }
 
 impl FromMeta for ClassEntryAttribute {
@@ -73,10 +81,15 @@ impl FromMeta for ClassEntryAttribute {
                         stub: explicit.stub,
                     })
                 } else {
+                    // Try to parse as string literal first: implements("\\JsonSerializable")
+                    if let Ok(lit) = list.parse_args::<syn::LitStr>() {
+                        return Ok(ClassEntryAttribute::Name(lit.value()));
+                    }
                     // Parse as simple type form: extends(TypeName)
                     let path: syn::Path = list.parse_args().map_err(|e| {
                         darling::Error::custom(format!(
-                            "Expected a type path (e.g., `MyClass`) or explicit form \
+                            "Expected a type path (e.g., `MyClass`), string literal \
+                             (e.g., `\"\\\\JsonSerializable\"`), or explicit form \
                              (e.g., `ce = expr, stub = \"Name\"`): {e}"
                         ))
                     })?;
@@ -105,6 +118,17 @@ 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
+                quote! {
+                    (
+                        || ::ext_php_rs::zend::ClassEntry::try_find_no_autoload(#name)
+                            .expect(concat!("Failed to find class entry for ", #name)),
+                        #name
+                    )
+                }
+            }
         };
         tokens.append_all(token);
     }

src/zend/ce.rs

@@ -7,8 +7,7 @@ use crate::ffi::{
     zend_ce_compile_error, zend_ce_countable, zend_ce_division_by_zero_error,
     zend_ce_error_exception, zend_ce_exception, zend_ce_iterator, zend_ce_parse_error,
     zend_ce_serializable, zend_ce_stringable, zend_ce_throwable, zend_ce_traversable,
-    zend_ce_type_error, zend_ce_unhandled_match_error, zend_ce_value_error,
-    zend_standard_class_def,
+    zend_ce_type_error, zend_ce_unhandled_match_error, zend_ce_value_error, zend_standard_class_def,
 };
 
 use super::ClassEntry;

src/zend/class.rs

@@ -35,6 +35,32 @@ impl ClassEntry {
         unsafe { crate::ffi::zend_lookup_class_ex(&raw mut *name, ptr::null_mut(), 0).as_ref() }
     }
 
+    /// Attempts to find a reference to a class in the global class table without
+    /// triggering autoloading.
+    ///
+    /// This is useful during module initialization when autoloading might not be
+    /// available or could cause issues.
+    ///
+    /// 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;
+
+        ExecutorGlobals::get().class_table()?;
+        let mut name = ZendStr::new(name, false);
+
+        unsafe {
+            crate::ffi::zend_lookup_class_ex(
+                &raw mut *name,
+                ptr::null_mut(),
+                ZEND_FETCH_CLASS_NO_AUTOLOAD,
+            )
+            .as_ref()
+        }
+    }
+
     /// Creates a new [`ZendObject`], returned inside an [`ZBox<ZendObject>`]
     /// wrapper.
     ///