[derive] Fix the 'simple' integeration tests

We now manage to auto-derive 'StaticReflect' appropriately.
Also, the 'field_offset!' macro has been updated to not involve
undefined behavior :D

Author: Techcable

lib/derive-internals/Cargo.toml

@@ -13,7 +13,3 @@ indexmap = "1.6"
 [dependencies.syn]
 version = "1"
 features = ["full", "extra-traits"]
-
-[dev-dependencies]
-# Testing
-static-reflect = { version = "0.1.0", path = "../.." }

lib/derive-internals/src/fields.rs

@@ -93,62 +93,61 @@ impl Parse for DeriveFieldOptions {
     }
 }
 
-pub fn derive_static_reflect(input: &DeriveInput) -> TokenStream {
+pub fn derive_static_reflect(input: &DeriveInput) -> Result<TokenStream, syn::Error> {
     let name = &input.ident;
     if !has_repr_c(&input) {
-        return syn::Error::new(
-            Span::call_site(),
+        return Err(syn::Error::new(
+            name.span(),
             "StaticReflect requires repr(C)"
-        ).to_compile_error().into()
+        ))
     }
 
     let generics = add_type_bounds(&input.generics, &[parse_quote!(::reflect::StaticReflect)]);
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
-    let mut verify_fields = Vec::new();
     let mut extra_defs = Vec::new();
     let static_type = match input.data {
         Data::Struct(ref data) => {
             handle_type(
                 StructHandler::new(data, name),
-                &mut verify_fields, &name,
+                &name,
                 quote!(#impl_generics),
                 quote!(#ty_generics),
                 quote!(#where_clause),
                 &mut extra_defs
-            )
+            )?
         },
-        Data::Enum(ref data) => enum_static_type(data, &name),
+        Data::Enum(ref data) => enum_static_type(data, &name)?,
         Data::Union(ref data) => {
             handle_type(
                 UnionTypeHandler { data, name },
-                &mut verify_fields, &name,
+                &name,
                 quote!(#impl_generics),
                 quote!(#ty_generics),
                 quote!(#where_clause),
                 &mut extra_defs
-            )
+            )?
         },
-    }.unwrap_or_else(|e| e.to_compile_error());
+    };
 
     let r = quote! {
         #(#extra_defs)*
-        impl #impl_generics static_reflect::StaticReflect for #name #ty_generics #where_clause {
-            const TYPE_INFO: static_reflect::types::TypeInfo<'static> = #static_type;
-        }
-        // NOTE: We've verified all our fields implement `NativeRepr`
-        unsafe impl #impl_generics static_reflect::NativeRepr for #name #ty_generics #where_clause {
-            const _VERIFY_TRANSPARENT_REPR: u32 = {
-                // Verify all our fields implement `NativeRepr`
-                0 #(+ #verify_fields)*
+        unsafe impl #impl_generics static_reflect::StaticReflect for #name #ty_generics #where_clause {
+            const TYPE_INFO: static_reflect::types::TypeInfo<'static> = {
+                /*
+                 * NOTE: All our fields are assumed to implement `StaticReflect`,
+                 * because there is no other way they could show up
+                 * in the generated `TypeInfo`.
+                 */
+                #static_type
             };
         }
     };
     crate::utils::debug_derive("StaticReflect", &input.ident, &r);
-    r.into()
+    Ok(r)
 }
 fn handle_type<'a, T: TypeHandler<'a>>(
-    mut target: T, verify_fields: &mut Vec<TokenStream>,
+    mut target: T,
     name: &Ident,
     impl_generics: TokenStream,
     ty_generics: TokenStream,
@@ -165,8 +164,6 @@ fn handle_type<'a, T: TypeHandler<'a>>(
         field_associated_types.push(quote!(type #field_name = #field_type;));
         let field_def_type = T::field_def_type(Some(quote!(#field_type)));
         field_defs.push(quote!(pub #field_name: #field_def_type,));
-        // NOTE: Must use size_of<#original_type> (See above)
-        verify_fields.push(field.verify_type());
     })?;
     let field_info_struct_name = Ident::new(
         &format!("_FieldInfo{}", name),
@@ -197,7 +194,7 @@ fn handle_type<'a, T: TypeHandler<'a>>(
         .map(|(name, def)| quote!(#name: #def,))
         .collect::<Vec<TokenStream>>();
     extra_defs.push(quote!(
-        impl #impl_generics static_reflect::FieldReflect for #name #ty_generics #where_clause {
+        unsafe impl #impl_generics static_reflect::FieldReflect for #name #ty_generics #where_clause {
             type NamedFieldInfo = #field_info_struct_name;
             const NAMED_FIELD_INFO: Self::NamedFieldInfo = #field_info_struct_name {
                 #(#field_inits)*
@@ -208,11 +205,11 @@ fn handle_type<'a, T: TypeHandler<'a>>(
     let field_def_type_name = T::field_def_type(None);
     let type_def_type = T::type_def_type();
     let header = quote! {
-        use static_reflect::{AsmRepr, AsmFieldInfo};
-        use static_reflect::types::AsmType;
+        use static_reflect::{StaticReflect, FieldReflect};
+        use static_reflect::types::TypeInfo;
         use #field_def_type_name;
         use #type_def_type;
-        const _FIELDS: &'static [#field_def_type_name<'static>] = &[#(<#name as AsmFieldInfo>::FIELD_INFO.#field_names.erase()),*];
+        const _FIELDS: &'static [#field_def_type_name<'static>] = &[#(<#name as FieldReflect>::NAMED_FIELD_INFO.#field_names.erase()),*];
     };
     let static_def = target.create_static_def(header);
     let into_type = T::def_into_type(quote!(_DEF));
@@ -246,12 +243,6 @@ struct FieldInfo<'a> {
     static_type: Type,
     static_def: TokenStream
 }
-impl<'a> FieldInfo<'a> {
-    fn verify_type(&self) -> TokenStream {
-        let field_type = &self.static_type;
-        quote!(<#field_type as ::static_reflect::StaticReflect>::_VERIFY_TRANSPARENT_REPR)
-    }
-}
 struct StructHandler<'a> {
     name: &'a Ident,
     data: &'a DataStruct,
@@ -399,7 +390,7 @@ impl<'a> TypeHandler<'a> for UnionTypeHandler<'a> {
     }
 
     fn def_into_type(def_ref: TokenStream) -> TokenStream {
-        quote!(static_reflect::types::AsmType::Union(#def_ref))
+        quote!(static_reflect::types::TypeInfo::Union(#def_ref))
     }
 
     fn handle_fields<F: FnMut(FieldInfo<'a>)>(&mut self, mut handler: F) -> syn::Result<()> {

lib/derive/Cargo.toml

@@ -10,8 +10,13 @@ proc-macro = true
 
 [dependencies]
 proc-macro2 = "^1"
+syn = "1"
 
 # Actual implementation
 [dependencies.static-reflect-derive-internals]
 version = "0.1.0"
 path = "../derive-internals"
+
+[dev-dependencies]
+# Testing
+static-reflect = { version = "0.1.0", path = "../.." }

lib/derive/src/lib.rs

@@ -1 +1,25 @@
-extern proc_macro;
+extern crate proc_macro;
+extern crate static_reflect_derive_internals as internals;
+
+use syn::{parse_macro_input, Item, DeriveInput};
+
+#[proc_macro_derive(StaticReflect, attributes(reflect, static_reflect))]
+pub fn derive_static_reflect(raw_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input: DeriveInput = parse_macro_input!(raw_input as DeriveInput);
+    match internals::fields::derive_static_reflect(&input) {
+        Ok(tokens) => tokens.into(),
+        Err(e) => e.into_compile_error().into()
+    }
+}
+
+
+#[proc_macro_attribute]
+pub fn reflect_func(args: proc_macro::TokenStream, input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let _original_input = input.clone();
+    let input: Item = parse_macro_input!(input as Item);
+    let args = parse_macro_input!(args as internals::func::FuncArgs);
+    match internals::derive_reflect_func(args, &input) {
+        Ok(tokens) => tokens.into(),
+        Err(e) => e.into_compile_error().into()
+    }
+}

lib/derive-internals/tests/funcs.rs renamed to lib/derive/tests/funcs.rs

@@ -2,7 +2,7 @@
 use std::os::raw::c_void;
 
 use duckasm_derive::duckasm_func;
-use duckasm_repr::AsmRepr;
+use static_repr::AsmRepr;
 use duckasm_repr::funcs::{FunctionDeclaration, FunctionLocation, SignatureDef};
 use duckasm_repr::types::AsmType;
 use std::marker::PhantomData;

lib/derive-internals/tests/simple.rs renamed to lib/derive/tests/simple.rs

@@ -3,22 +3,22 @@
     // const_fn is used by AsmType
     const_fn, const_panic
 )]
-use duckasm_repr::field_offset;
-use duckasm_repr::{AsmRepr, AsmFieldInfo};
-use duckasm_repr::types::{AsmType, FieldDef, StructureDef, UnionDef, UnionFieldDef, TypeId};
+
+use static_reflect::{field_offset, StaticReflect, FieldReflect};
+use static_reflect::types::{TypeInfo, FieldDef, StructureDef, UnionDef, UnionFieldDef, TypeId};
 use std::mem::{size_of, align_of};
 
-use duckasm_derive::{AsmRepr};
+use static_reflect_derive::{StaticReflect};
 
-#[derive(Copy, Clone, Debug, PartialEq, AsmRepr)]
+#[derive(Copy, Clone, Debug, PartialEq, StaticReflect)]
 #[repr(C)]
 pub struct Nested {
     cycle: *mut SimpleStruct,
     float: f64,
     number: u64,
 }
 
-#[derive(AsmRepr)]
+#[derive(StaticReflect)]
 #[repr(C)]
 pub struct SimpleStruct {
     // We can have pointers to anything
@@ -38,7 +38,7 @@ fn leak_vec<T>(elements: Vec<T>) -> &'static [T] {
 }
 
 #[repr(C)]
-#[derive(AsmRepr)]
+#[derive(StaticReflect)]
 union SimpleUnion {
     pub text: *mut String,
     b: bool,
@@ -48,34 +48,34 @@ union SimpleUnion {
 
 #[test]
 fn test_union_types() {
-    const EXPECTED_UNION: AsmType<'static> = AsmType::Union(&UnionDef {
+    const EXPECTED_UNION: TypeInfo<'static> = TypeInfo::Union(&UnionDef {
         name: "SimpleUnion",
         fields: &[
-            SimpleUnion::FIELD_INFO.text.erase(),
-            SimpleUnion::FIELD_INFO.b.erase(),
-            SimpleUnion::FIELD_INFO.f.erase(),
-            SimpleUnion::FIELD_INFO.nested.erase(),
+            SimpleUnion::NAMED_FIELD_INFO.text.erase(),
+            SimpleUnion::NAMED_FIELD_INFO.b.erase(),
+            SimpleUnion::NAMED_FIELD_INFO.f.erase(),
+            SimpleUnion::NAMED_FIELD_INFO.nested.erase(),
         ],
         size: size_of::<SimpleUnion>(),
         alignment: align_of::<SimpleUnion>()
     });
-    assert_eq!(EXPECTED_UNION, SimpleUnion::STATIC_TYPE);
-    assert_eq!(SimpleUnion::FIELD_INFO.text, UnionFieldDef {
+    assert_eq!(EXPECTED_UNION, SimpleUnion::TYPE_INFO);
+    assert_eq!(SimpleUnion::NAMED_FIELD_INFO.text, UnionFieldDef {
         name: "text",
         value_type: TypeId::<*mut String>::get(),
         index: 0
     });
-    assert_eq!(SimpleUnion::FIELD_INFO.b, UnionFieldDef {
+    assert_eq!(SimpleUnion::NAMED_FIELD_INFO.b, UnionFieldDef {
         name: "b",
         value_type: TypeId::<bool>::get(),
         index: 1
     });
-    assert_eq!(SimpleUnion::FIELD_INFO.f, UnionFieldDef {
+    assert_eq!(SimpleUnion::NAMED_FIELD_INFO.f, UnionFieldDef {
         name: "f",
         value_type: TypeId::<f32>::get(),
         index: 2
     });
-    assert_eq!(SimpleUnion::FIELD_INFO.nested, UnionFieldDef {
+    assert_eq!(SimpleUnion::NAMED_FIELD_INFO.nested, UnionFieldDef {
         name: "nested",
         value_type: TypeId::<Nested>::get(),
         index: 3
@@ -84,30 +84,30 @@ fn test_union_types() {
 
 #[test]
 fn test_struct_types() {
-    const NESTED_TYPE: AsmType<'static> = AsmType::Structure(&StructureDef {
+    const NESTED_TYPE: TypeInfo<'static> = TypeInfo::Structure(&StructureDef {
         name: "Nested",
         fields: &[
-            Nested::FIELD_INFO.cycle.erase(),
-            Nested::FIELD_INFO.float.erase(),
-            Nested::FIELD_INFO.number.erase(),
+            Nested::NAMED_FIELD_INFO.cycle.erase(),
+            Nested::NAMED_FIELD_INFO.float.erase(),
+            Nested::NAMED_FIELD_INFO.number.erase(),
         ],
         size: size_of::<Nested>(),
         alignment: align_of::<Nested>()
     });
-    assert_eq!(Nested::STATIC_TYPE, NESTED_TYPE);
-    assert_eq!(Nested::FIELD_INFO.cycle, FieldDef {
+    assert_eq!(Nested::TYPE_INFO, NESTED_TYPE);
+    assert_eq!(Nested::NAMED_FIELD_INFO.cycle, FieldDef {
         name: "cycle",
         value_type: TypeId::<*mut SimpleStruct>::get(),
         offset: field_offset!(Nested, cycle),
         index: 0
     });
-    assert_eq!(Nested::FIELD_INFO.float, FieldDef {
+    assert_eq!(Nested::NAMED_FIELD_INFO.float, FieldDef {
         name: "float",
         value_type: TypeId::<f64>::get(),
         offset: field_offset!(Nested, float),
         index: 1
     });
-    assert_eq!(Nested::FIELD_INFO.number, FieldDef {
+    assert_eq!(Nested::NAMED_FIELD_INFO.number, FieldDef {
         name: "number",
         value_type: TypeId::<u64>::get(),
         offset: field_offset!(Nested, number),
@@ -154,8 +154,8 @@ fn test_struct_types() {
     ];
     let static_fields = leak_vec(fields);
     assert_eq!(
-        SimpleStruct::STATIC_TYPE,
-        AsmType::Structure(&StructureDef {
+        SimpleStruct::TYPE_INFO,
+        TypeInfo::Structure(&StructureDef {
             name: "SimpleStruct",
             fields: static_fields,
             size: size_of::<SimpleStruct>(),
@@ -164,34 +164,34 @@ fn test_struct_types() {
     );
 }
 
-#[derive(AsmRepr)]
+#[derive(StaticReflect)]
 #[repr(C)]
 struct OpaqueArray {
-    #[duckasm(assume_repr = "i8")]
+    #[reflect(assume_repr = "i8")]
     first: u8,
-    #[duckasm(opaque_array)]
+    #[static_reflect(opaque_array)]
     array: [*mut String; 42]
 }
 
 #[test]
 fn test_options() {
-    const OPAQUE_ARRAY_TYPE: AsmType<'static> = AsmType::Structure(&StructureDef {
+    const OPAQUE_ARRAY_TYPE: TypeInfo<'static> = TypeInfo::Structure(&StructureDef {
         name: "OpaqueArray",
         fields: &[
-            OpaqueArray::FIELD_INFO.first.erase(),
-            OpaqueArray::FIELD_INFO.array.erase(),
+            OpaqueArray::NAMED_FIELD_INFO.first.erase(),
+            OpaqueArray::NAMED_FIELD_INFO.array.erase(),
         ],
         size: size_of::<OpaqueArray>(),
         alignment: align_of::<OpaqueArray>()
     });
-    assert_eq!(OPAQUE_ARRAY_TYPE, OpaqueArray::STATIC_TYPE);
-    assert_eq!(OpaqueArray::FIELD_INFO.first, FieldDef {
+    assert_eq!(OPAQUE_ARRAY_TYPE, OpaqueArray::TYPE_INFO);
+    assert_eq!(OpaqueArray::NAMED_FIELD_INFO.first, FieldDef {
         name: "first",
         value_type: TypeId::<i8>::get(), // It's actually a 'u8', but we assume_repr
         offset: field_offset!(OpaqueArray, first),
         index: 0
     });
-    assert_eq!(OpaqueArray::FIELD_INFO.array, FieldDef {
+    assert_eq!(OpaqueArray::NAMED_FIELD_INFO.array, FieldDef {
         name: "array",
         value_type: TypeId::<*mut String>::get(),
         offset: field_offset!(OpaqueArray, array),