[derive] Fix the tests for function reflection

Author: Techcable

lib/derive-internals/src/func.rs

@@ -228,14 +228,14 @@ fn emit_def_from_signature(
             FnArg::Typed(ref item) => {
                 let ty = &item.ty;
                 static_arg_types.push(quote!(#ty));
-                argument_types.push(quote!(<#ty as duckasm_repr::AsmRepr>::STATIC_TYPE))
+                argument_types.push(quote!(<#ty as static_reflect::StaticReflect>::TYPE_INFO))
             },
         }
     }
     let return_type = match item.output {
-        ReturnType::Default => quote!(&duckasm_repr::types::AsmType::Unit),
+        ReturnType::Default => quote!(&static_reflect::types::TypeInfo::Unit),
         ReturnType::Type(_, ref ty) => {
-            quote!(&<#ty as duckasm_repr::AsmRepr>::STATIC_TYPE)
+            quote!(&<#ty as static_reflect::StaticReflect>::TYPE_INFO)
         },
     };
     let signature = StaticSignatureDef { argument_types, return_type };
@@ -285,8 +285,9 @@ impl StaticFunctionDef {
         quote! {
             #[doc(hidden)]
             #[allow(non_snake_case)]
-            pub const #const_name: duckasm_repr::funcs::FunctionDeclaration<#return_type, #arg_types> = {
-                #(<#verify_types as duckasm_repr::NativeRepr>::_VERIFY_TRANSPARENT_REPR;)*
+            pub const #const_name: static_reflect::funcs::FunctionDeclaration<#return_type, #arg_types> = {
+                // Verify all the types implement [StaticReflect]
+                #(let _ = <#verify_types as static_reflect::StaticReflect>::TYPE_INFO;)*
                 #def
             };
         }
@@ -317,7 +318,7 @@ impl ToTokens for StaticFunctionDef {
             ref static_return_type,
             static_arg_types: ref staitc_arg_types
         } = *self;
-        tokens.append_all(quote!(duckasm_repr::funcs::FunctionDeclaration::<'static, #static_return_type, #staitc_arg_types> {
+        tokens.append_all(quote!(static_reflect::funcs::FunctionDeclaration::<'static, #static_return_type, #staitc_arg_types> {
             name: #name,
             is_unsafe: #is_unsafe,
             signature: #signature,
@@ -332,13 +333,13 @@ impl ToTokens for FunctionLocation {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         tokens.append_all(match *self {
             FunctionLocation::DynamicallyLinked { link_name: None } => {
-                quote!(duckasm_repr::funcs::FunctionLocation::DynamicallyLinked { link_name: None })
+                quote!(Some(static_reflect::funcs::FunctionLocation::DynamicallyLinked { link_name: None }))
             },
             FunctionLocation::DynamicallyLinked { link_name: Some(ref name) } => {
-                quote!(duckasm_repr::funcs::FunctionLocation::DynamicallyLinked { link_name: Some(#name) })
+                quote!(Some(static_reflect::funcs::FunctionLocation::DynamicallyLinked { link_name: Some(#name) }))
             },
             FunctionLocation::AbsoluteAddress(ref value) => {
-                quote!(duckasm_repr::funcs::FunctionLocation::AbsoluteAddress(#value))
+                quote!(Some(static_reflect::funcs::FunctionLocation::AbsoluteAddress(#value)))
             },
         });
     }
@@ -350,11 +351,11 @@ impl ToTokens for StaticSignatureDef {
             ref argument_types,
             ref return_type
         } = *self;
-        tokens.append_all(quote!(duckasm_repr::funcs::SignatureDef {
+        tokens.append_all(quote!(static_reflect::funcs::SignatureDef {
             argument_types: &[#(#argument_types),*],
             return_type: #return_type,
             // We use C FFI
-            calling_convention: duckasm_repr::funcs::CallingConvention::StandardC
+            calling_convention: static_reflect::funcs::CallingConvention::StandardC
         }))
     }
 }

lib/derive/tests/funcs.rs

@@ -1,38 +1,38 @@
 #![feature(const_raw_ptr_to_usize_cast)]
 use std::os::raw::c_void;
 
-use duckasm_derive::duckasm_func;
-use static_repr::AsmRepr;
-use duckasm_repr::funcs::{FunctionDeclaration, FunctionLocation, SignatureDef};
-use duckasm_repr::types::AsmType;
+use static_reflect_derive::reflect_func;
+use static_reflect::StaticReflect;
+use static_reflect::funcs::{FunctionDeclaration, FunctionLocation, SignatureDef};
+use static_reflect::types::{TypeInfo, FloatSize};
 use std::marker::PhantomData;
 
-#[duckasm_func]
+#[reflect_func]
 #[export_name = "better_name"]
 extern "C" fn stupid_name(first: f32, second: f32) {
     eprintln!("Test {}: {}", first, second);
 }
 
 #[no_mangle]
-#[duckasm_func]
+#[reflect_func]
 unsafe extern "C" fn dynamically_linked(first: u32, second: *mut String) -> f32 {
     eprintln!("Test {}: {}", first, &*second);
     3.14
 }
 
-#[duckasm_func(
+#[reflect_func(
     absolute // NOTE: This removes the requirement for #[no_mangle]
 )]
 extern "C" fn absolute_address_example(x: f64, y: f64) -> f64 {
     (x * x + y * y).sqrt()
 }
 
-#[duckasm_func]
+#[reflect_func]
 extern "C" {
     /*
      * TODO: These are considered 'dead' even though DuckAsm uses them
      * Just because they're not invoked directly by Rust code,
-     * doesn't mean their are actually unused.....
+     * doesn't mean they are actually unused.....
      */
     #[allow(dead_code)]
     #[link_name = "sqrtf"]
@@ -48,10 +48,10 @@ fn extern_block() {
         FunctionDeclaration::<*mut c_void, (usize,)> {
             name: "malloc",
             is_unsafe: true, // Foreign functions are always unsafe (in spite of lack of keyword)
-            location: FunctionLocation::DynamicallyLinked { link_name: None },
+            location: Some(FunctionLocation::DynamicallyLinked { link_name: None }),
             signature: SignatureDef {
-                argument_types: &[usize::STATIC_TYPE],
-                return_type: &AsmType::Pointer,
+                argument_types: &[usize::TYPE_INFO],
+                return_type: &TypeInfo::Pointer,
                 calling_convention: Default::default()
             },
             return_type: PhantomData,
@@ -63,10 +63,10 @@ fn extern_block() {
         FunctionDeclaration::<f32, (f32,)> {
             name: "sqrt",
             is_unsafe: true, // NOTE: Foreign function
-            location: FunctionLocation::DynamicallyLinked { link_name: Some("sqrtf".into()) },
+            location: Some(FunctionLocation::DynamicallyLinked { link_name: Some("sqrtf".into()) }),
             signature: SignatureDef {
-                argument_types: &[f32::STATIC_TYPE],
-                return_type: &f32::STATIC_TYPE,
+                argument_types: &[f32::TYPE_INFO],
+                return_type: &f32::TYPE_INFO,
                 calling_convention: Default::default()
             },
             return_type: PhantomData,
@@ -84,10 +84,10 @@ fn rust_funcs() {
         FunctionDeclaration::<f32, (u32, *mut String)> {
             name: "dynamically_linked",
             is_unsafe: true,
-            location: FunctionLocation::DynamicallyLinked { link_name: None },
+            location: Some(FunctionLocation::DynamicallyLinked { link_name: None }),
             signature: SignatureDef {
-                argument_types: &[u32::STATIC_TYPE, AsmType::Pointer],
-                return_type: &AsmType::Float { bytes: 4 },
+                argument_types: &[u32::TYPE_INFO, TypeInfo::Pointer],
+                return_type: &TypeInfo::F32,
                 calling_convention: Default::default()
             },
             return_type: PhantomData,
@@ -99,10 +99,10 @@ fn rust_funcs() {
         FunctionDeclaration::<(), (f32, f32)> {
             name: "stupid_name",
             is_unsafe: false,
-            location: FunctionLocation::DynamicallyLinked { link_name: Some("better_name".into()) },
+            location: Some(FunctionLocation::DynamicallyLinked { link_name: Some("better_name".into()) }),
             signature: SignatureDef {
-                argument_types: &[f32::STATIC_TYPE, AsmType::Float { bytes: 4 }],
-                return_type: &AsmType::Unit,
+                argument_types: &[f32::TYPE_INFO, TypeInfo::Float { size: FloatSize::Single }],
+                return_type: &TypeInfo::Unit,
                 calling_convention: Default::default()
             },
             return_type: PhantomData,
@@ -114,10 +114,10 @@ fn rust_funcs() {
         FunctionDeclaration::<f64, (f64, f64)> {
             name: "absolute_address_example",
             is_unsafe: false,
-            location: FunctionLocation::AbsoluteAddress(absolute_address_example as *const ()),
+            location: Some(FunctionLocation::AbsoluteAddress(absolute_address_example as *const ())),
             signature: SignatureDef {
-                argument_types: &[f64::STATIC_TYPE, f64::STATIC_TYPE],
-                return_type: &f64::STATIC_TYPE,
+                argument_types: &[f64::TYPE_INFO, f64::TYPE_INFO],
+                return_type: &f64::TYPE_INFO,
                 calling_convention: Default::default()
             },
             return_type: PhantomData,

src/funcs.rs

@@ -0,0 +1,90 @@
+//! Reflection information on function declarations
+use crate::types::{TypeInfo};
+use std::marker::PhantomData;
+
+/// The declaration of a function whose information
+/// is known to the static reflection system
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct FunctionDeclaration<'a, R = (), Args = ()> {
+    /// The name of the function, as declared in the
+    /// source code.
+    pub name: &'a str,
+    /// If the function is unsafe
+    pub is_unsafe: bool,
+    /// The location of the function (if known)
+    ///
+    /// Not all supported functions have a known location.
+    pub location: Option<FunctionLocation>,
+    /// The signature of the function, including
+    /// its arguments and return types
+    ///
+    /// Unlike the [PhantomData], this is actually retained at runtime.
+    pub signature: SignatureDef<'a>,
+    /// PhantomData: The return type of the function 
+    pub return_type: PhantomData<*mut R>,
+    /// PhantomData: The argument types of the function
+    pub arg_types: PhantomData<*mut Args>,
+}
+impl<'a, R, Args> FunctionDeclaration<'a, R, Args> {
+    /// If the function has a known location at runtime
+    ///
+    /// If this is false, it wont actually be possible
+    /// to call the function later. If it is true,
+    /// then you can.
+    #[inline]
+    pub fn has_known_location(&self) -> bool {
+        self.location.is_some()
+    }
+    /// Erase all statically known type information
+    #[inline]
+    pub fn erase(&'a self) -> &'a FunctionDeclaration<(), ()> {
+        unsafe { &*(self as *const Self as *const FunctionDeclaration<(), ()>) }
+    }
+}
+/// The definition of a function's signature
+///
+/// Includes its argument types, return type, and calling convention.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SignatureDef<'tp> {
+    /// A list of argument types to the function
+    pub argument_types: &'tp [TypeInfo<'tp>],
+    /// The return type of the function
+    pub return_type: &'tp TypeInfo<'tp>,
+    /// The calling convention
+    pub calling_convention: CallingConvention
+}
+
+
+/// The convention used to call code.
+///
+/// Currently, only the C calling convention is supported
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum CallingConvention {
+    /// Matches the target's C calling convention `extern "C"`
+    ///
+    /// This is the default calling convention.
+    /// It has a stable ABI and is used to call external functions
+    StandardC,
+}
+impl Default for CallingConvention {
+    #[inline]
+    fn default() -> Self {
+        CallingConvention::StandardC
+    }
+}
+
+/// The location of the function
+///
+/// Gives specific information on which function to invoke
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum FunctionLocation {
+    /// The function is in a dynamically linked library,
+    /// which will need to be resolved by the linker
+    DynamicallyLinked {
+        /// The name to be linked against,
+        /// or `None` if it's the same as the function's name
+        link_name: Option<&'static str>
+    },
+    /// The function is referred to by an absolute (hardcoded) address
+    AbsoluteAddress(*const ()),
+}

src/lib.rs

@@ -19,6 +19,7 @@
 #[cfg(feature = "builtins")]
 pub mod builtins;
 pub mod types;
+pub mod funcs;
 
 mod core;