feat(class): Static properties and methods #252

Author: kakserpom

allowed_bindings.rs

@@ -87,6 +87,8 @@ bind! {
     zend_declare_class_constant,
     zend_declare_property,
     zend_do_implement_interface,
+    zend_read_static_property,
+    zend_update_static_property,
     zend_enum_add_case,
     zend_enum_get_case,
     zend_enum_new,

crates/macros/src/class.rs

@@ -76,6 +76,8 @@ pub fn parser(mut input: ItemStruct) -> Result<TokenStream> {
 #[darling(attributes(php), forward_attrs(doc), default)]
 struct PropAttributes {
     prop: Flag,
+    #[darling(rename = "static")]
+    static_: Flag,
     #[darling(flatten)]
     rename: PhpRename,
     flags: Option<Expr>,
@@ -114,6 +116,10 @@ impl Property<'_> {
             .rename
             .rename(self.ident.to_string(), RenameRule::Camel)
     }
+
+    pub fn is_static(&self) -> bool {
+        self.attr.static_.is_present()
+    }
 }
 
 /// Generates an implementation of `RegisteredClass` for struct `ident`.
@@ -130,9 +136,14 @@ fn generate_registered_class_impl(
 ) -> TokenStream {
     let modifier = modifier.option_tokens();
 
-    let fields = fields.iter().map(|prop| {
+    // Separate instance properties from static properties
+    let (instance_props, static_props): (Vec<_>, Vec<_>) =
+        fields.iter().partition(|prop| !prop.is_static());
+
+    // Generate instance properties (with Rust handlers)
+    let instance_fields = instance_props.iter().map(|prop| {
         let name = prop.name();
-        let ident = prop.ident;
+        let field_ident = prop.ident;
         let flags = prop
             .attr
             .flags
@@ -143,13 +154,33 @@ fn generate_registered_class_impl(
 
         quote! {
             (#name, ::ext_php_rs::internal::property::PropertyInfo {
-                prop: ::ext_php_rs::props::Property::field(|this: &mut Self| &mut this.#ident),
+                prop: ::ext_php_rs::props::Property::field(|this: &mut Self| &mut this.#field_ident),
                 flags: #flags,
                 docs: &[#(#docs,)*]
             })
         }
     });
 
+    // Generate static properties (PHP-managed, no Rust handlers)
+    // We combine the base flags with Static flag using from_bits_retain which is const
+    let static_fields = static_props.iter().map(|prop| {
+        let name = prop.name();
+        let base_flags = prop
+            .attr
+            .flags
+            .as_ref()
+            .map(ToTokens::to_token_stream)
+            .unwrap_or(quote! { ::ext_php_rs::flags::PropertyFlags::Public });
+        let docs = &prop.docs;
+
+        // Use from_bits_retain to combine flags in a const context
+        quote! {
+            (#name, ::ext_php_rs::flags::PropertyFlags::from_bits_retain(
+                (#base_flags).bits() | ::ext_php_rs::flags::PropertyFlags::Static.bits()
+            ), &[#(#docs,)*] as &[&str])
+        }
+    });
+
     let flags = match flags {
         Some(flags) => flags.to_token_stream(),
         None => quote! { ::ext_php_rs::flags::ClassFlags::empty() }.to_token_stream(),
@@ -204,10 +235,16 @@ fn generate_registered_class_impl(
             > {
                 use ::std::iter::FromIterator;
                 ::std::collections::HashMap::from_iter([
-                    #(#fields,)*
+                    #(#instance_fields,)*
                 ])
             }
 
+            #[must_use]
+            fn static_properties() -> &'static [(&'static str, ::ext_php_rs::flags::PropertyFlags, &'static [&'static str])] {
+                static STATIC_PROPS: &[(&str, ::ext_php_rs::flags::PropertyFlags, &[&str])] = &[#(#static_fields,)*];
+                STATIC_PROPS
+            }
+
             #[inline]
             fn method_builders() -> ::std::vec::Vec<
                 (::ext_php_rs::builders::FunctionBuilder<'static>, ::ext_php_rs::flags::MethodFlags)

crates/macros/tests/expand/class.expanded.rs

@@ -27,6 +27,15 @@ impl ::ext_php_rs::class::RegisteredClass for MyClass {
         use ::std::iter::FromIterator;
         ::std::collections::HashMap::from_iter([])
     }
+    #[must_use]
+    fn static_properties() -> &'static [(
+        &'static str,
+        ::ext_php_rs::flags::PropertyFlags,
+        &'static [&'static str],
+    )] {
+        static STATIC_PROPS: &[(&str, ::ext_php_rs::flags::PropertyFlags, &[&str])] = &[];
+        STATIC_PROPS
+    }
     #[inline]
     fn method_builders() -> ::std::vec::Vec<
         (

src/builders/module.rs

@@ -254,6 +254,9 @@ impl ModuleBuilder<'_> {
             for (name, prop_info) in T::get_properties() {
                 builder = builder.property(name, prop_info.flags, prop_info.docs);
             }
+            for (name, flags, docs) in T::static_properties() {
+                builder = builder.property(*name, *flags, docs);
+            }
             if let Some(modifier) = T::BUILDER_MODIFIER {
                 builder = modifier(builder);
             }

src/class.rs

@@ -13,7 +13,7 @@ use crate::{
     convert::IntoZvalDyn,
     describe::DocComments,
     exception::PhpException,
-    flags::{ClassFlags, MethodFlags},
+    flags::{ClassFlags, MethodFlags, PropertyFlags},
     internal::property::PropertyInfo,
     zend::{ClassEntry, ExecuteData, ZendObjectHandlers},
 };
@@ -72,6 +72,15 @@ pub trait RegisteredClass: Sized + 'static {
 
     /// Returns the constants provided by the class.
     fn constants() -> &'static [(&'static str, &'static dyn IntoZvalDyn, DocComments)];
+
+    /// Returns the static properties provided by the class.
+    ///
+    /// Static properties are declared at the class level and managed by PHP,
+    /// not by Rust handlers. Each tuple contains (name, flags, docs).
+    #[must_use]
+    fn static_properties() -> &'static [(&'static str, PropertyFlags, DocComments)] {
+        &[]
+    }
 }
 
 /// Stores metadata about a classes Rust constructor, including the function

src/zend/class.rs

@@ -4,11 +4,14 @@ use crate::ffi::instanceof_function_slow;
 use crate::types::{ZendIterator, Zval};
 use crate::{
     boxed::ZBox,
+    convert::{FromZval, IntoZval},
+    error::Result,
     ffi::zend_class_entry,
     flags::ClassFlags,
     types::{ZendObject, ZendStr},
     zend::ExecutorGlobals,
 };
+use std::ffi::CString;
 use std::ptr;
 use std::{convert::TryInto, fmt::Debug};
 
@@ -132,6 +135,74 @@ impl ClassEntry {
     pub fn name(&self) -> Option<&str> {
         unsafe { self.name.as_ref().and_then(|s| s.as_str().ok()) }
     }
+
+    /// Reads a static property from the class.
+    ///
+    /// # Parameters
+    ///
+    /// * `name` - The name of the static property to read.
+    ///
+    /// # Returns
+    ///
+    /// Returns the value of the static property if it exists and can be
+    /// converted to type `T`, or `None` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ext_php_rs::zend::ClassEntry;
+    ///
+    /// let ce = ClassEntry::try_find("MyClass").unwrap();
+    /// let value: Option<i64> = ce.get_static_property("counter");
+    /// ```
+    #[must_use]
+    pub fn get_static_property<'a, T: FromZval<'a>>(&'a self, name: &str) -> Option<T> {
+        let name = CString::new(name).ok()?;
+        let zval = unsafe {
+            crate::ffi::zend_read_static_property(
+                ptr::from_ref(self).cast_mut(),
+                name.as_ptr(),
+                name.as_bytes().len(),
+                true, // silent - don't throw if property doesn't exist
+            )
+            .as_ref()?
+        };
+        T::from_zval(zval)
+    }
+
+    /// Sets a static property on the class.
+    ///
+    /// # Parameters
+    ///
+    /// * `name` - The name of the static property to set.
+    /// * `value` - The value to set the property to.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the property name contains a null byte, or if the
+    /// value could not be converted to a Zval.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ext_php_rs::zend::ClassEntry;
+    ///
+    /// let ce = ClassEntry::try_find("MyClass").unwrap();
+    /// ce.set_static_property("counter", 42).unwrap();
+    /// ```
+    pub fn set_static_property<T: IntoZval>(&self, name: &str, value: T) -> Result<()> {
+        let name = CString::new(name)?;
+        let mut zval = value.into_zval(false)?;
+        unsafe {
+            crate::ffi::zend_update_static_property(
+                ptr::from_ref(self).cast_mut(),
+                name.as_ptr(),
+                name.as_bytes().len(),
+                &raw mut zval,
+            );
+        }
+        Ok(())
+    }
 }
 
 impl PartialEq for ClassEntry {

tests/src/integration/class/class.php

@@ -51,3 +51,46 @@
 
 $classReflection = new ReflectionClass(TestClassProtectedConstruct::class);
 assert($classReflection->getMethod('__construct')->isProtected());
+
+// Test static properties (Issue #252)
+$staticObj = new TestStaticProps(42);
+assert($staticObj->instanceValue === 42, 'Instance property should work');
+
+// Verify static property exists and is accessible
+$reflection = new ReflectionClass(TestStaticProps::class);
+$staticCounterProp = $reflection->getProperty('staticCounter');
+assert($staticCounterProp->isStatic(), 'staticCounter should be a static property');
+assert($staticCounterProp->isPublic(), 'staticCounter should be public');
+
+// Verify private static property
+$privateStaticProp = $reflection->getProperty('privateStatic');
+assert($privateStaticProp->isStatic(), 'privateStatic should be a static property');
+assert($privateStaticProp->isPrivate(), 'privateStatic should be private');
+
+// Test accessing static property via class
+TestStaticProps::$staticCounter = 100;
+assert(TestStaticProps::$staticCounter === 100, 'Should be able to set and get static property');
+
+// Test that static property is shared across instances
+$obj1 = new TestStaticProps(1);
+$obj2 = new TestStaticProps(2);
+TestStaticProps::$staticCounter = 200;
+assert(TestStaticProps::$staticCounter === 200, 'Static property value should be shared');
+
+// Test static methods that interact with static properties
+TestStaticProps::setCounter(0);
+assert(TestStaticProps::getCounter() === 0, 'Counter should be 0 after reset');
+
+TestStaticProps::incrementCounter();
+assert(TestStaticProps::getCounter() === 1, 'Counter should be 1 after increment');
+
+TestStaticProps::incrementCounter();
+TestStaticProps::incrementCounter();
+assert(TestStaticProps::getCounter() === 3, 'Counter should be 3 after 3 increments');
+
+// Test that PHP access and Rust access see the same value
+TestStaticProps::$staticCounter = 50;
+assert(TestStaticProps::getCounter() === 50, 'Rust should see PHP-set value');
+
+TestStaticProps::setCounter(100);
+assert(TestStaticProps::$staticCounter === 100, 'PHP should see Rust-set value');

tests/src/integration/class/mod.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::unused_self)]
 use ext_php_rs::{
+    class::RegisteredClass,
     convert::IntoZval,
     prelude::*,
     types::{ZendClassObject, Zval},
@@ -175,6 +176,53 @@ impl TestClassProtectedConstruct {
     }
 }
 
+/// Test class with static properties (Issue #252)
+#[php_class]
+pub struct TestStaticProps {
+    /// Instance property for comparison
+    #[php(prop)]
+    pub instance_value: i32,
+    /// Static property - managed by PHP, not Rust handlers
+    #[php(prop, static)]
+    pub static_counter: i32,
+    /// Private static property
+    #[php(prop, static, flags = ext_php_rs::flags::PropertyFlags::Private)]
+    pub private_static: String,
+}
+
+#[php_impl]
+impl TestStaticProps {
+    pub fn __construct(value: i32) -> Self {
+        Self {
+            instance_value: value,
+            // Note: static fields have default values in PHP, not from Rust constructor
+            static_counter: 0,
+            private_static: String::new(),
+        }
+    }
+
+    /// Static method to increment the static counter
+    pub fn increment_counter() {
+        let ce = Self::get_metadata().ce();
+        let current: i64 = ce.get_static_property("staticCounter").unwrap_or(0);
+        ce.set_static_property("staticCounter", current + 1)
+            .expect("Failed to set static property");
+    }
+
+    /// Static method to get the current counter value
+    pub fn get_counter() -> i64 {
+        let ce = Self::get_metadata().ce();
+        ce.get_static_property("staticCounter").unwrap_or(0)
+    }
+
+    /// Static method to set the counter to a specific value
+    pub fn set_counter(value: i64) {
+        let ce = Self::get_metadata().ce();
+        ce.set_static_property("staticCounter", value)
+            .expect("Failed to set static property");
+    }
+}
+
 pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
     builder
         .class::<TestClass>()
@@ -183,6 +231,7 @@ pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
         .class::<TestClassExtendsImpl>()
         .class::<TestClassMethodVisibility>()
         .class::<TestClassProtectedConstruct>()
+        .class::<TestStaticProps>()
         .function(wrap_function!(test_class))
         .function(wrap_function!(throw_exception))
 }