Make types check more flexible

Author: mekosko

riscv-rt/macros/src/lib.rs

@@ -11,8 +11,9 @@ extern crate syn;
 use proc_macro2::Span;
 use syn::{
     parse::{self, Parse},
+    punctuated::Punctuated,
     spanned::Spanned,
-    FnArg, ItemFn, LitInt, LitStr, PatType, PathArguments, ReturnType, Type, Visibility,
+    FnArg, ItemFn, LitInt, LitStr, PatType, ReturnType, Type, Visibility,
 };
 
 use proc_macro::TokenStream;
@@ -67,10 +68,10 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
         .into();
     }
 
-    fn check_simple_type(argument: &PatType, ty: &str) -> Option<TokenStream> {
+    fn check_correct_type(argument: &PatType, ty: &str) -> Option<TokenStream> {
         let inv_type_message = format!("argument type must be {}", ty);
 
-        if !is_simple_type(&argument.ty, ty) {
+        if !is_correct_type(&argument.ty, ty) {
             let error = parse::Error::new(argument.ty.span(), inv_type_message);
 
             Some(error.to_compile_error().into())
@@ -83,7 +84,7 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
         let argument_error = argument_error.to_compile_error().into();
 
         match argument {
-            FnArg::Typed(argument) => check_simple_type(argument, ty),
+            FnArg::Typed(argument) => check_correct_type(argument, ty),
             FnArg::Receiver(_) => Some(argument_error),
         }
     }
@@ -101,7 +102,7 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
     }
     #[cfg(feature = "u-boot")]
     if let Some(argument) = f.sig.inputs.get(1) {
-        if let Some(message) = check_argument_type(argument, "usize") {
+        if let Some(message) = check_argument_type(argument, "*const *const c_char") {
             return message;
         }
     }
@@ -151,17 +152,32 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
     .into()
 }
 
-#[allow(unused)]
-fn is_simple_type(ty: &Type, name: &str) -> bool {
-    if let Type::Path(p) = ty {
-        if p.qself.is_none() && p.path.leading_colon.is_none() && p.path.segments.len() == 1 {
-            let segment = p.path.segments.first().unwrap();
-            if segment.ident == name && segment.arguments == PathArguments::None {
-                return true;
-            }
+fn strip_type_path(ty: &Type) -> Option<Type> {
+    match ty {
+        Type::Ptr(ty) => {
+            let mut ty = ty.clone();
+            ty.elem = Box::new(strip_type_path(&ty.elem)?);
+            Some(Type::Ptr(ty))
         }
+        Type::Path(ty) => {
+            let mut ty = ty.clone();
+            let last_segment = ty.path.segments.last().unwrap().clone();
+            ty.path.segments = Punctuated::new();
+            ty.path.segments.push_value(last_segment);
+            Some(Type::Path(ty))
+        }
+        _ => None,
+    }
+}
+
+#[allow(unused)]
+fn is_correct_type(ty: &Type, name: &str) -> bool {
+    let correct: Type = syn::parse_str(name).unwrap();
+    if let Some(ty) = strip_type_path(ty) {
+        ty == correct
+    } else {
+        false
     }
-    false
 }
 
 /// Attribute to mark which function will be called at the beginning of the reset handler.