feat: Describe interface classes

Author: Aleksandr Startsev

src/builders/class.rs

@@ -58,6 +58,10 @@ impl ClassBuilder {
         }
     }
 
+    pub fn get_flags(&self) -> u32 {
+        self.ce.ce_flags
+    }
+
     /// Sets the class builder to extend another class.
     ///
     /// # Parameters

src/describe/mod.rs

@@ -7,7 +7,7 @@ use crate::builders::EnumBuilder;
 use crate::{
     builders::{ClassBuilder, FunctionBuilder},
     constant::IntoConst,
-    flags::{DataType, MethodFlags, PropertyFlags},
+    flags::{ClassFlags, DataType, MethodFlags, PropertyFlags},
     prelude::ModuleBuilder,
 };
 use abi::{Option, RString, Str, Vec};
@@ -193,6 +193,8 @@ pub struct Class {
     pub methods: Vec<Method>,
     /// Constants of the class.
     pub constants: Vec<Constant>,
+    /// Class flags
+    pub flags: u32,
 }
 
 #[cfg(feature = "closure")]
@@ -225,15 +227,18 @@ impl Class {
                 }),
                 r#static: false,
                 visibility: Visibility::Public,
+                r#abstract: false
             }]
             .into(),
             constants: StdVec::new().into(),
+            flags: 0,
         }
     }
 }
 
 impl From<ClassBuilder> for Class {
     fn from(val: ClassBuilder) -> Self {
+        let flags = val.get_flags();
         Self {
             name: val.name.into(),
             docs: DocBlock(
@@ -269,6 +274,7 @@ impl From<ClassBuilder> for Class {
                 .map(Constant::from)
                 .collect::<StdVec<_>>()
                 .into(),
+            flags: flags
         }
     }
 }
@@ -416,6 +422,8 @@ pub struct Method {
     pub r#static: bool,
     /// Visibility of the method.
     pub visibility: Visibility,
+    /// Not describe method body, if is abstract.
+    pub r#abstract: bool,
 }
 
 impl From<(FunctionBuilder<'_>, MethodFlags)> for Method {
@@ -448,6 +456,7 @@ impl From<(FunctionBuilder<'_>, MethodFlags)> for Method {
             ty: flags.into(),
             r#static: flags.contains(MethodFlags::Static),
             visibility: flags.into(),
+            r#abstract: flags.contains(MethodFlags::Abstract),
         }
     }
 }
@@ -685,6 +694,7 @@ mod tests {
                 retval: Option::None,
                 r#static: false,
                 visibility: Visibility::Protected,
+                r#abstract: false
             }
         );
     }

src/describe/stub.rs

@@ -16,7 +16,7 @@ use super::{
 
 #[cfg(feature = "enum")]
 use crate::describe::{Enum, EnumCase};
-use crate::flags::DataType;
+use crate::flags::{ClassFlags, DataType};
 
 /// Implemented on types which can be converted into PHP stubs.
 pub trait ToStub {
@@ -226,13 +226,20 @@ impl ToStub for Class {
         self.docs.fmt_stub(buf)?;
 
         let (_, name) = split_namespace(self.name.as_ref());
-        write!(buf, "class {name} ")?;
+        let flags = ClassFlags::from_bits(self.flags).unwrap();
+        let is_interface = flags.contains(ClassFlags::Interface);
+
+        if is_interface {
+            write!(buf, "interface {name} ")?;
+        } else {
+            write!(buf, "class {name} ")?;
+        }
 
         if let Option::Some(extends) = &self.extends {
             write!(buf, "extends {extends} ")?;
         }
 
-        if !self.implements.is_empty() {
+        if !self.implements.is_empty() && !is_interface {
             write!(
                 buf,
                 "implements {} ",
@@ -244,6 +251,18 @@ impl ToStub for Class {
             )?;
         }
 
+        if !self.implements.is_empty() && is_interface {
+            write!(
+                buf,
+                "extends {} ",
+                self.implements
+                    .iter()
+                    .map(RString::as_str)
+                    .collect::<StdVec<_>>()
+                    .join(", ")
+            )?;
+        }
+
         writeln!(buf, "{{")?;
 
         buf.push_str(
@@ -360,7 +379,11 @@ impl ToStub for Method {
             }
         }
 
-        writeln!(buf, " {{}}")
+        if !self.r#abstract {
+            writeln!(buf, " {{}}")
+        } else {
+            writeln!(buf, ";")
+        }
     }
 }