libm-analyze: a proc macro to analyze libm APIs

This proc macro takes a macro of the form:

```
macro_rules! nop {
    (
        id: $id:ident;
        arg_tys: $($arg_tys:ty),*;
        arg_ids: $($arg_ids:ident),*;
        ret: $ty:ty;
    ) => {};
}
```

as input and expands it on every public libm API. This facilitates generating
tests, benchmarks, etc. for all APIs.

Author: gnzlbg

Cargo.toml

@@ -2,7 +2,7 @@
 members = [
   "crates/libm",
   "crates/libm-analyze",
-  "crates/libm-verify",
+  "crates/libm-test",
   "crates/compiler-builtins-smoke-test",
   "crates/libm-bench",
 ]

crates/libm-analyze/Cargo.toml

@@ -1,16 +1,19 @@
 [package]
 name = "libm-analyze"
 version = "0.1.0"
-authors = ["gnzlbg <[email protected]>"]
+authors = ["Gonzalo Brito Gadeschi <[email protected]>"]
 edition = "2018"
 
 [lib]
 proc-macro = true
 test = false
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 syn = { version = "0.15", features = ["full", "extra-traits"] }
 quote = "0.6"
-walkdir = "2.2.8"
+walkdir = "2.2.8"
+proc-macro2 = "0.4"
+
+[features]
+default = ["analyze"]
+analyze = []

crates/libm-analyze/src/lib.rs

@@ -2,25 +2,41 @@
 
 extern crate proc_macro;
 use self::proc_macro::TokenStream;
+use quote::quote;
+use syn::parse_macro_input;
 
 #[proc_macro]
 pub fn for_each_api(input: TokenStream) -> TokenStream {
     let files = get_libm_files();
     let functions = get_functions(files);
-    input
+    let input = parse_macro_input!(input as syn::Ident);
+    let mut tokens = proc_macro2::TokenStream::new();
+    for function in functions {
+        let id = function.ident;
+        let ret_ty = function.ret_ty;
+        let arg_tys = function.arg_tys;
+        let arg_ids = get_arg_ids(arg_tys.len());
+        let t = quote! {
+            #input! {
+                id: #id;
+                arg_tys: #(#arg_tys),*;
+                arg_ids: #(#arg_ids),*;
+                ret: #ret_ty;
+            }
+        };
+        tokens.extend(t);
+    }
+    tokens.into()
 }
 
 /// Traverses the libm crate directory, parsing all .rs files
 fn get_libm_files() -> Vec<(syn::File, String)> {
     let root_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    dbg!(&root_dir);
     let libm_dir = root_dir
         .parent()
         .expect("couldn't access crates/ dir")
         .join("libm");
-    dbg!(&libm_dir);
     let libm_src_dir = libm_dir.join("src");
-    dbg!(&libm_src_dir);
 
     let mut files = Vec::new();
     for entry in walkdir::WalkDir::new(libm_src_dir)
@@ -38,7 +54,6 @@ fn get_libm_files() -> Vec<(syn::File, String)> {
             continue;
         }
 
-        eprintln!("{}", file_path.display());
         let mut file_string = String::new();
         std::fs::File::open(&file_path)
             .unwrap_or_else(|_| panic!("can't open file at path: {}", file_path.display()))
@@ -53,17 +68,33 @@ fn get_libm_files() -> Vec<(syn::File, String)> {
 struct FnSig {
     ident: syn::Ident,
     unsafety: bool,
-    constness: bool,
-    asyncness: bool,
-    attrs: Vec<syn::Attribute>,
-    abi: &'static str,
+    c_abi: bool,
+    ret_ty: Option<syn::Type>,
+    arg_tys: Vec<syn::Type>,
+}
+
+impl FnSig {
+    fn name(&self) -> String {
+        self.ident.to_string()
+    }
+}
 
+macro_rules! syn_to_str {
+    ($e:expr) => {{
+        let t = $e;
+        let tokens = quote! {
+            #t
+        };
+        format!("{}", tokens)
+    }};
 }
 
 /// Extracts all public functions from the libm files.
-fn get_functions(files: Vec<(syn::File, String)>) {
-    //let mut functions = Vec::new();
+fn get_functions(files: Vec<(syn::File, String)>) -> Vec<FnSig> {
+    let mut error = false;
+    let mut functions = Vec::new();
     for item in files.iter().flat_map(|f| f.0.items.iter()) {
+        let mut e = false;
         match item {
             syn::Item::Fn(syn::ItemFn {
                 vis: syn::Visibility::Public(_),
@@ -76,21 +107,167 @@ fn get_functions(files: Vec<(syn::File, String)>) {
                 decl,
                 block: _,
             }) => {
-                if let Some(syn::Abi { name: Some(l), extern_token: _ }) = abi {
-                    println!("{:#?}", l);
-                    if l.value() != "C" {
-                        l.span().unwrap().warning(
-                            "public libm function is not `extern \"C\""
-                        ).emit();
+                let mut fn_sig = FnSig {
+                    ident: ident.clone(),
+                    unsafety: true,
+                    c_abi: false,
+                    arg_tys: Vec::new(),
+                    ret_ty: None,
+                };
+                macro_rules! err {
+                    ($msg:expr) => {{
+                        #[cfg(feature = "analyze")]
+                        {
+                            eprintln!("[error]: Function \"{}\" {}", fn_sig.name(), $msg);
+                        }
+                        #[allow(unused_assignments)]
+                        {
+                            e = true;
+                        }
+                        ()
+                    }};
+                }
+                if let Some(syn::Abi {
+                    name: Some(l),
+                    extern_token: _,
+                }) = abi
+                {
+                    if l.value() == "C" {
+                        fn_sig.c_abi = true;
+                    }
+                }
+                if let Some(_) = constness {
+                    err!("is const");
+                }
+                if let Some(_) = asyncness {
+                    err!("is async");
+                }
+                if &None == unsafety {
+                    fn_sig.unsafety = false;
+                }
+                let syn::FnDecl {
+                    fn_token: _,
+                    generics,
+                    paren_token: _,
+                    inputs,
+                    variadic,
+                    output,
+                } = (**decl).clone();
+
+                if variadic.is_some() {
+                    err!(format!(
+                        "contains variadic arguments \"{}\"",
+                        syn_to_str!(variadic.unwrap())
+                    ));
+                }
+                if generics.type_params().into_iter().count() != 0 {
+                    err!(format!(
+                        "contains generic parameters \"{}\"",
+                        syn_to_str!(generics.clone())
+                    ));
+                }
+                if generics.lifetimes().into_iter().count() != 0 {
+                    err!(format!(
+                        "contains lifetime parameters \"{}\"",
+                        syn_to_str!(generics.clone())
+                    ));
+                }
+                if generics.const_params().into_iter().count() != 0 {
+                    err!(format!(
+                        "contains const parameters \"{}\"",
+                        syn_to_str!(generics.clone())
+                    ));
+                }
+                if attrs.is_empty() {
+                    err!(format!(
+                        "missing `#[inline]` and `#[no_panic]` attributes {}",
+                        attrs
+                            .iter()
+                            .map(|a| syn_to_str!(a))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    ));
+                } // TODO: might want to check other attributes as well
+                if !fn_sig.c_abi {
+                    // FIXME: do not disable test if this fails - otherwise no test passes
+                    let e2 = e;
+                    err!("not `extern \"C\"`");
+                    e = e2;
+                }
+                match output {
+                    syn::ReturnType::Default => (),
+                    syn::ReturnType::Type(_, ref b) if valid_ty(&b) => {
+                        fn_sig.ret_ty = Some(*b.clone())
+                    }
+                    other => err!(format!("returns unsupported type {}", syn_to_str!(other))),
+                }
+                for input in inputs {
+                    match input {
+                        syn::FnArg::Captured(ref c) if valid_ty(&c.ty) => {
+                            fn_sig.arg_tys.push(c.ty.clone())
+                        }
+                        other => err!(format!(
+                            "takes unsupported argument type {}",
+                            syn_to_str!(other)
+                        )),
                     }
+                }
+                if !e {
+                    functions.push(fn_sig);
                 } else {
-                    ident.span().unwrap().warning(
-                        "public libm function is not `extern \"C\""
-                    ).emit();
+                    error = true;
                 }
-                println!("{:#?}", ident);
             }
             _ => (),
         }
     }
+    if error {
+        // too many errors:
+        //        panic!("errors found");
+    }
+    functions
+}
+
+/// Parses a type into a String - arg is true if the type is an argument, and
+/// false if its a return value.
+fn valid_ty(t: &syn::Type) -> bool {
+    match t {
+        syn::Type::Ptr(p) => {
+            let c = p.const_token.is_some();
+            let m = p.mutability.is_some();
+            assert!(!(c && m));
+            match &*p.elem {
+                syn::Type::Path(_) => valid_ty(&p.elem),
+                // Only one layer of pointers allowed:
+                _ => false,
+            }
+        }
+        syn::Type::Path(p) => {
+            assert!(p.qself.is_none());
+            assert_eq!(p.path.segments.len(), 1);
+            let s = p
+                .path
+                .segments
+                .first()
+                .unwrap()
+                .into_value()
+                .ident
+                .to_string();
+            match s.as_str() {
+                "i8" | "i16" | "i32" | "i64" | "isize" | "u8" | "u16" | "u32" | "u64" | "usize"
+                | "f32" | "f64" => true,
+                _ => false,
+            }
+        }
+        _ => false,
+    }
+}
+
+fn get_arg_ids(len: usize) -> Vec<syn::Ident> {
+    let mut ids = Vec::new();
+    for i in 0..len {
+        let x = format!("x{}", i);
+        ids.push(syn::Ident::new(&x, proc_macro2::Span::call_site()));
+    }
+    ids
 }

crates/libm-analyze/tests/analyze.rs

@@ -0,0 +1,13 @@
+//! Tests that the proc-macro accepts macros with
+//! the following pattern:
+
+macro_rules! nop {
+    (
+        id: $id:ident;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret: $ty:ty;
+    ) => {};
+}
+
+libm_analyze::for_each_api!(nop);