feat: adding support for struct inheritages

Author: WolverinDEV

examples/minimal/src/main.rs

@@ -1,6 +1,7 @@
 use std::{
     self,
     error::Error,
+    marker,
     sync::Arc,
 };
 
@@ -19,23 +20,29 @@ use raw_struct::{
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
-    let mut memory = [0u8; 0x40];
+    let mut memory = [0u8; 0x80];
     memory[0..4].copy_from_slice(&0x6Fu32.to_le_bytes());
     memory[4..8].copy_from_slice(&0x99u32.to_le_bytes());
+    memory[0x40..0x44].copy_from_slice(&0xFF00FFu32.to_le_bytes());
 
     println!("{}", <dyn MyStruct as Copyable>::MEMORY_SIZE);
 
     let memory = Arc::new(CopyMemoryView::new(memory));
     {
         let object = Reference::<dyn MyStruct, _>::new(memory.clone(), 0x00);
-        println!("field_a = {}", object.field_a()?);
-        println!("field_b = {}", object.field_b()?);
+        println!("field_a = {:X}", object.field_a()?);
+        println!("field_b = {:X}", object.field_b()?);
+
+        let object_ex = object.cast::<dyn MyStructExt>();
+        println!("ex field_b = {:X}", object_ex.field_b()?);
+        println!("ex ext_field_a = {:X}", object_ex.ext_field_a()?);
+        println!("X a & b combined = {:X}", object_ex.first_t()?);
     }
 
     {
         let object = Copy::<dyn MyStruct>::read_object(&*memory, 0x00)?;
-        println!("field_a = {}", object.field_a()?);
-        println!("field_b = {}", object.field_b()?);
+        println!("field_a = {:X}", object.field_a()?);
+        println!("field_b = {:X}", object.field_b()?);
     }
 
     Ok(())
@@ -78,9 +85,18 @@ struct MyStruct {
     pub field_g: [u8; 0x20],
 }
 
+#[raw_struct(memory = "T")]
+struct X<T>
+where
+    T: marker::Copy + Send + Sync + 'static,
+{
+    #[field(offset = "0x00")]
+    first_t: T,
+}
+
 #[raw_struct(size = 0x44)]
+#[inherits(MyStruct, X::<u64>)]
 struct MyStructExt {
     #[field(offset = 0x40)]
     pub ext_field_a: u32,
 }
-impl MyStruct for dyn MyStructExt {}

raw_struct_derive/src/derive_raw_struct.rs

@@ -8,6 +8,7 @@ use syn::{
         Parse,
         ParseStream,
     },
+    parse_quote,
     punctuated::Punctuated,
     spanned::Spanned,
     Attribute,
@@ -22,6 +23,8 @@ use syn::{
     Lit,
     LitStr,
     MetaNameValue,
+    Path,
+    PathArguments,
     Result,
     Token,
     TypeGenerics,
@@ -209,6 +212,7 @@ struct ViewableGenerator<'a> {
     args: StructArgs,
 
     attributes: Vec<&'a Attribute>,
+    inherits: Vec<Path>,
     fields: Vec<ViewableField<'a>>,
 
     generics_impl: ImplGenerics<'a>,
@@ -236,26 +240,37 @@ impl<'a> ViewableGenerator<'a> {
         }
     }
 
-    fn parse_attributes(target: &'a ItemStruct) -> Result<Vec<&'a Attribute>> {
-        target
-            .attrs
-            .iter()
-            .map(|attr| {
-                if attr.path.is_ident("doc") {
-                    Ok(attr)
-                } else {
-                    Err(Error::new(
+    fn parse_attributes(target: &'a ItemStruct) -> Result<(Vec<&'a Attribute>, Vec<Path>)> {
+        let mut attributes = Vec::with_capacity(target.attrs.len());
+        let mut inherits = None;
+
+        for attr in &target.attrs {
+            if attr.path.is_ident("doc") {
+                attributes.push(attr);
+            } else if attr.path.is_ident("inherits") {
+                if inherits.is_some() {
+                    return Err(Error::new(
                         attr.span(),
-                        "only \"doc\" attributes are supported on raw_structs",
-                    ))
+                        "only one instance of the \"inherits\" attributes is supported",
+                    ));
                 }
-            })
-            .collect::<Result<Vec<_>>>()
+
+                let args = attr.parse_args_with(Punctuated::<Path, Token![,]>::parse_terminated)?;
+                inherits = Some(args.iter().cloned().collect::<Vec<_>>());
+            } else {
+                return Err(Error::new(
+                    attr.span(),
+                    "only \"doc\" or \"inherits\" attributes are supported on raw_structs",
+                ));
+            }
+        }
+
+        Ok((attributes, inherits.unwrap_or_default()))
     }
 
     fn new(target: &'a ItemStruct, target_args: StructArgs) -> Result<Self> {
         let fields = Self::parse_fields(&target)?;
-        let attributes = Self::parse_attributes(&target)?;
+        let (attributes, inherits) = Self::parse_attributes(&target)?;
 
         let (generics_impl, generics_type, generics_where) = target.generics.split_for_impl();
 
@@ -285,6 +300,7 @@ impl<'a> ViewableGenerator<'a> {
             args: target_args,
 
             attributes,
+            inherits,
             fields,
 
             generics_impl,
@@ -410,6 +426,36 @@ impl<'a> ViewableGenerator<'a> {
                 for #instance_name<A, MemoryView> { }
         }
     }
+
+    fn generate_inheritances(&self) -> TokenStream {
+        let accessor_name = &self.accessor_name;
+        let (accessor_impl_generics, accessor_ty_generics, accessor_where_clause) =
+            self.accessor_generics.split_for_impl();
+
+        let mut inheritances = Vec::with_capacity(self.inherits.len());
+        for path in &self.inherits {
+            let mut path = path.clone();
+            let Some(last) = path.segments.last_mut() else {
+                panic!("expected a path to have at least one segment");
+            };
+
+            last.ident = Ident::new(&format!("{}_Accessor", last.ident), last.span());
+            last.arguments = match &last.arguments {
+                PathArguments::None => PathArguments::AngleBracketed(parse_quote! { <MemoryView> }),
+                PathArguments::Parenthesized(_) => unreachable!(),
+                PathArguments::AngleBracketed(value) => {
+                    let args = value.args.iter();
+                    PathArguments::AngleBracketed(parse_quote! { <MemoryView, #(#args,)*> })
+                }
+            };
+
+            inheritances.push(quote! {
+                impl #accessor_impl_generics #path for dyn #accessor_name #accessor_ty_generics #accessor_where_clause {}
+            });
+        }
+
+        quote! { #(#inheritances)* }
+    }
 }
 
 pub fn raw_struct(attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
@@ -432,12 +478,19 @@ pub fn raw_struct(attr: TokenStream, input: TokenStream) -> Result<TokenStream>
     //     generator.generate_instance_struct().to_string()
     // );
 
+    // println!(
+    //     "/* Inheritances: */ {}",
+    //     generator.generate_inheritances().to_string()
+    // );
+
     let main_trait = generator.generate_main_trait();
     let accessors = generator.generate_accessor_trait();
     let instance = generator.generate_instance_struct();
+    let inheritances = generator.generate_inheritances();
     Ok(quote! {
         #main_trait
         #accessors
         #instance
+        #inheritances
     })
 }

raw_struct_derive/src/lib.rs

@@ -6,8 +6,12 @@ mod derive_raw_struct;
 /// Marks a struct as a representation of a C-style struct with memory-mapped fields.
 ///
 /// # Supported Attributes:  
-/// - `size = "<struct size>"` (required)  
-///   Defines the total memory size of the struct.
+/// - `#[raw_struct(...)]`
+///   - `size = "<struct size>"` (required)  
+///     Defines the total memory size of the struct.
+/// - `#[inherits(...)]`  
+///   One or multiple base classes similar to the `#[derive(...)]` attribute.  
+///   Note: base classes must be raw_structs as well.
 ///
 /// Each field within the struct must be annotated with the `#[field(...)]` attribute.
 ///