fix(stubs): Missing property types #184

kakserpom · kakserpom · commit 31579a5cd821 · 2026-02-10T09:59:50.000+07:00
diff --git a/crates/macros/src/class.rs b/crates/macros/src/class.rs
@@ -2,9 +2,63 @@ use darling::util::Flag;
 use darling::{FromAttributes, FromMeta, ToTokens};
 use proc_macro2::TokenStream;
 use quote::{TokenStreamExt, quote};
-use syn::{Attribute, Expr, Fields, ItemStruct};
+use syn::{Attribute, Expr, Fields, GenericArgument, ItemStruct, PathArguments, Type};
 
 use crate::helpers::get_docs;
+
+/// Check if a type is `Option<T>` and return the inner type if so.
+fn is_option_type(ty: &Type) -> Option<&Type> {
+    let Type::Path(type_path) = ty else {
+        return None;
+    };
+    if type_path.qself.is_some() {
+        return None;
+    }
+    let segments = &type_path.path.segments;
+    if segments.len() != 1 {
+        return None;
+    }
+    let segment = &segments[0];
+    if segment.ident != "Option" {
+        return None;
+    }
+    let PathArguments::AngleBracketed(args) = &segment.arguments else {
+        return None;
+    };
+    if args.args.len() != 1 {
+        return None;
+    }
+    if let GenericArgument::Type(inner) = &args.args[0] {
+        return Some(inner);
+    }
+    None
+}
+
+/// Convert an expression to a PHP-compatible default string for stub generation.
+fn expr_to_php_default_string(expr: &Expr) -> String {
+    // For simple literals, we can convert them directly
+    // For complex expressions, we use a string representation
+    match expr {
+        Expr::Lit(lit) => match &lit.lit {
+            syn::Lit::Str(s) => format!("'{}'", s.value().replace('\'', "\\'")),
+            syn::Lit::Int(i) => i.to_string(),
+            syn::Lit::Float(f) => f.to_string(),
+            syn::Lit::Bool(b) => if b.value { "true" } else { "false" }.to_string(),
+            _ => expr.to_token_stream().to_string(),
+        },
+        Expr::Array(_) => "[]".to_string(),
+        Expr::Path(path) => {
+            // Handle constants like `None`, `true`, `false`
+            let path_str = path.to_token_stream().to_string();
+            if path_str == "None" {
+                "null".to_string()
+            } else {
+                path_str
+            }
+        }
+        _ => expr.to_token_stream().to_string(),
+    }
+}
 use crate::parsing::{PhpNameContext, PhpRename, RenameRule, ident_to_php_name, validate_php_name};
 use crate::prelude::*;
 
@@ -192,6 +246,7 @@ fn parse_fields<'a>(fields: impl Iterator<Item = &'a mut syn::Field>) -> Result<
 
             result.push(Property {
                 ident,
+                ty: &field.ty,
                 name,
                 attr,
                 docs,
@@ -205,6 +260,7 @@ fn parse_fields<'a>(fields: impl Iterator<Item = &'a mut syn::Field>) -> Result<
 #[derive(Debug)]
 struct Property<'a> {
     pub ident: &'a syn::Ident,
+    pub ty: &'a syn::Type,
     pub name: String,
     pub attr: PropAttributes,
     pub docs: Vec<String>,
@@ -240,6 +296,7 @@ fn generate_registered_class_impl(
     let instance_fields = instance_props.iter().map(|prop| {
         let name = &prop.name;
         let field_ident = prop.ident;
+        let field_ty = prop.ty;
         let flags = prop
             .attr
             .flags
@@ -248,11 +305,25 @@ fn generate_registered_class_impl(
             .unwrap_or(quote! { ::ext_php_rs::flags::PropertyFlags::Public });
         let docs = &prop.docs;
 
+        // Determine if the property is nullable (type is Option<T>)
+        let nullable = is_option_type(field_ty).is_some();
+
+        // Get the default value as a PHP-compatible string for stub generation
+        let default_str = if let Some(default_expr) = &prop.attr.default {
+            let s = expr_to_php_default_string(default_expr);
+            quote! { ::std::option::Option::Some(#s) }
+        } else {
+            quote! { ::std::option::Option::None }
+        };
+
         quote! {
             (#name, ::ext_php_rs::internal::property::PropertyInfo {
                 prop: ::ext_php_rs::props::Property::field(|this: &mut Self| &mut this.#field_ident),
                 flags: #flags,
-                docs: &[#(#docs,)*]
+                docs: &[#(#docs,)*],
+                ty: ::std::option::Option::Some(<#field_ty as ::ext_php_rs::convert::IntoZval>::TYPE),
+                nullable: #nullable,
+                default: #default_str,
             })
         }
     });
@@ -262,6 +333,7 @@ fn generate_registered_class_impl(
     // const
     let static_fields = static_props.iter().map(|prop| {
         let name = &prop.name;
+        let field_ty = prop.ty;
         let base_flags = prop
             .attr
             .flags
@@ -277,11 +349,23 @@ fn generate_registered_class_impl(
             quote! { ::std::option::Option::None }
         };
 
+        // Determine if the property is nullable (type is Option<T>)
+        let nullable = is_option_type(field_ty).is_some();
+
+        // Get the default value as a PHP-compatible string for stub generation
+        let default_str = if let Some(default_expr) = &prop.attr.default {
+            let s = expr_to_php_default_string(default_expr);
+            quote! { ::std::option::Option::Some(#s) }
+        } else {
+            quote! { ::std::option::Option::None }
+        };
+
         // Use from_bits_retain to combine flags in a const context
+        // Tuple: (name, flags, default_value, docs, type, nullable, default_str)
         quote! {
             (#name, ::ext_php_rs::flags::PropertyFlags::from_bits_retain(
                 (#base_flags).bits() | ::ext_php_rs::flags::PropertyFlags::Static.bits()
-            ), #default_value, &[#(#docs,)*] as &[&str])
+            ), #default_value, &[#(#docs,)*] as &[&str], ::std::option::Option::Some(<#field_ty as ::ext_php_rs::convert::IntoZval>::TYPE), #nullable, #default_str)
         }
     });
 
@@ -391,8 +475,9 @@ fn generate_registered_class_impl(
             }
 
             #[must_use]
-            fn static_properties() -> &'static [(&'static str, ::ext_php_rs::flags::PropertyFlags, ::std::option::Option<&'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync)>, &'static [&'static str])] {
-                static STATIC_PROPS: &[(&str, ::ext_php_rs::flags::PropertyFlags, ::std::option::Option<&'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync)>, &[&str])] = &[#(#static_fields,)*];
+            #[allow(clippy::type_complexity)]
+            fn static_properties() -> &'static [(&'static str, ::ext_php_rs::flags::PropertyFlags, ::std::option::Option<&'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync)>, &'static [&'static str], ::std::option::Option<::ext_php_rs::flags::DataType>, bool, ::std::option::Option<&'static str>)] {
+                static STATIC_PROPS: &[(&str, ::ext_php_rs::flags::PropertyFlags, ::std::option::Option<&'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync)>, &[&str], ::std::option::Option<::ext_php_rs::flags::DataType>, bool, ::std::option::Option<&'static str>)] = &[#(#static_fields,)*];
                 STATIC_PROPS
             }
 
diff --git a/crates/macros/src/impl_.rs b/crates/macros/src/impl_.rs
@@ -479,6 +479,11 @@ impl<'a> ParsedImpl<'a> {
                             prop: #prop_expr,
                             flags: #flags,
                             docs: &[#(#docs),*],
+                            // Type info not available for getter/setter-based properties
+                            ty: ::std::option::Option::None,
+                            // Nullable and default not available for getter/setter-based properties
+                            nullable: false,
+                            default: ::std::option::Option::None,
                         }
                     );
                 }
diff --git a/crates/macros/tests/expand/class.expanded.rs b/crates/macros/tests/expand/class.expanded.rs
@@ -37,11 +37,15 @@ impl ::ext_php_rs::class::RegisteredClass for MyClass {
         props
     }
     #[must_use]
+    #[allow(clippy::type_complexity)]
     fn static_properties() -> &'static [(
         &'static str,
         ::ext_php_rs::flags::PropertyFlags,
         ::std::option::Option<&'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync)>,
         &'static [&'static str],
+        ::std::option::Option<::ext_php_rs::flags::DataType>,
+        bool,
+        ::std::option::Option<&'static str>,
     )] {
         static STATIC_PROPS: &[(
             &str,
@@ -50,6 +54,9 @@ impl ::ext_php_rs::class::RegisteredClass for MyClass {
                 &'static (dyn ::ext_php_rs::convert::IntoZvalDyn + Sync),
             >,
             &[&str],
+            ::std::option::Option<::ext_php_rs::flags::DataType>,
+            bool,
+            ::std::option::Option<&'static str>,
         )] = &[];
         STATIC_PROPS
     }
diff --git a/src/builders/class.rs b/src/builders/class.rs
@@ -17,6 +17,8 @@ use crate::{
     zend_fastcall,
 };
 
+use crate::flags::DataType;
+
 /// A constant entry: (name, `value_closure`, docs, `stub_value`)
 type ConstantEntry = (
     String,
@@ -25,6 +27,16 @@ type ConstantEntry = (
     String,
 );
 type PropertyDefault = Option<Box<dyn FnOnce() -> Result<Zval>>>;
+/// A property entry: (name, flags, default, docs, type, nullable, `default_str`).
+type PropertyEntry = (
+    String,
+    PropertyFlags,
+    PropertyDefault,
+    DocComments,
+    Option<DataType>,
+    bool,
+    Option<&'static str>,
+);
 
 /// Builder for registering a class in PHP.
 #[must_use]
@@ -35,7 +47,7 @@ pub struct ClassBuilder {
     pub(crate) interfaces: Vec<ClassEntryInfo>,
     pub(crate) methods: Vec<(FunctionBuilder<'static>, MethodFlags)>,
     object_override: Option<unsafe extern "C" fn(class_type: *mut ClassEntry) -> *mut ZendObject>,
-    pub(crate) properties: Vec<(String, PropertyFlags, PropertyDefault, DocComments)>,
+    pub(crate) properties: Vec<PropertyEntry>,
     pub(crate) constants: Vec<ConstantEntry>,
     register: Option<fn(&'static mut ClassEntry)>,
     pub(crate) docs: DocComments,
@@ -114,14 +126,22 @@ impl ClassBuilder {
     /// * `flags` - Flags relating to the property. See [`PropertyFlags`].
     /// * `default` - Optional default value for the property.
     /// * `docs` - Documentation comments for the property.
+    /// * `ty` - Optional type for stub generation.
+    /// * `nullable` - Whether the property is nullable.
+    /// * `default_str` - Default value as PHP string for stub generation.
+    #[allow(clippy::too_many_arguments)]
     pub fn property<T: Into<String>>(
         mut self,
         name: T,
         flags: PropertyFlags,
         default: PropertyDefault,
         docs: DocComments,
+        ty: Option<DataType>,
+        nullable: bool,
+        default_str: Option<&'static str>,
     ) -> Self {
-        self.properties.push((name.into(), flags, default, docs));
+        self.properties
+            .push((name.into(), flags, default, docs, ty, nullable, default_str));
         self
     }
 
@@ -396,7 +416,7 @@ impl ClassBuilder {
             unsafe { zend_do_implement_interface(class, ptr::from_ref(interface).cast_mut()) };
         }
 
-        for (name, flags, default, _) in self.properties {
+        for (name, flags, default, _, _ty, _nullable, _default_str) in self.properties {
             let mut default_zval = match default {
                 Some(f) => f()?,
                 None => Zval::new(),
@@ -482,13 +502,23 @@ mod tests {
 
     #[test]
     fn test_property() {
-        let class =
-            ClassBuilder::new("Foo").property("bar", PropertyFlags::Public, None, &["Doc 1"]);
+        let class = ClassBuilder::new("Foo").property(
+            "bar",
+            PropertyFlags::Public,
+            None,
+            &["Doc 1"],
+            None,
+            false,
+            None,
+        );
         assert_eq!(class.properties.len(), 1);
         assert_eq!(class.properties[0].0, "bar");
         assert_eq!(class.properties[0].1, PropertyFlags::Public);
         assert!(class.properties[0].2.is_none());
         assert_eq!(class.properties[0].3, &["Doc 1"] as DocComments);
+        assert!(class.properties[0].4.is_none());
+        assert!(!class.properties[0].5); // nullable
+        assert!(class.properties[0].6.is_none()); // default_str
     }
 
     #[test]
diff --git a/src/builders/module.rs b/src/builders/module.rs
@@ -418,14 +418,30 @@ impl ModuleBuilder<'_> {
                     .expect("Failed to register constant");
             }
             for (name, prop_info) in T::get_properties() {
-                builder = builder.property(name, prop_info.flags, None, prop_info.docs);
+                builder = builder.property(
+                    name,
+                    prop_info.flags,
+                    None,
+                    prop_info.docs,
+                    prop_info.ty,
+                    prop_info.nullable,
+                    prop_info.default,
+                );
             }
-            for (name, flags, default, docs) in T::static_properties() {
+            for (name, flags, default, docs, ty, nullable, default_str) in T::static_properties() {
                 let default_fn = default.map(|v| {
                     Box::new(move || v.as_zval(true))
                         as Box<dyn FnOnce() -> crate::error::Result<crate::types::Zval>>
                 });
-                builder = builder.property(*name, *flags, default_fn, docs);
+                builder = builder.property(
+                    *name,
+                    *flags,
+                    default_fn,
+                    docs,
+                    *ty,
+                    *nullable,
+                    *default_str,
+                );
             }
             if let Some(modifier) = T::BUILDER_MODIFIER {
                 builder = modifier(builder);
diff --git a/src/class.rs b/src/class.rs
@@ -76,14 +76,22 @@ pub trait RegisteredClass: Sized + 'static {
     /// 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, default, docs).
-    /// The default value is optional - `None` means null default.
+    /// not by Rust handlers. Each tuple contains:
+    /// (name, flags, `default_value`, docs, type, nullable, `default_str`).
+    /// - `default_value` is the actual PHP default value (None means null)
+    /// - `type` is for stub generation
+    /// - `nullable` indicates if the property accepts null
+    /// - `default_str` is the PHP-compatible default string for stubs
     #[must_use]
+    #[allow(clippy::type_complexity)]
     fn static_properties() -> &'static [(
         &'static str,
         PropertyFlags,
         Option<&'static (dyn IntoZvalDyn + Sync)>,
         DocComments,
+        Option<crate::flags::DataType>,
+        bool,
+        Option<&'static str>,
     )] {
         &[]
     }
diff --git a/src/describe/mod.rs b/src/describe/mod.rs
diff --git a/src/internal/property.rs b/src/internal/property.rs

Original file line number	Diff line number	Diff line change
`@@ -479,6 +479,11 @@ impl<'a> ParsedImpl<'a> {`
`479`	`479`	`prop: #prop_expr,`
`480`	`480`	`flags: #flags,`
`481`	`481`	`docs: &[#(#docs),*],`
	`482`	`+ // Type info not available for getter/setter-based properties`
	`483`	`+ ty: ::std::option::Option::None,`
	`484`	`+ // Nullable and default not available for getter/setter-based properties`
	`485`	`+ nullable: false,`
	`486`	`+ default: ::std::option::Option::None,`
`482`	`487`	`}`
`483`	`488`	`);`
`484`	`489`	`}`