Merge pull request rust-lang#377 from tgross35/shared-function-list

Share a list of all functions between `libm-macros` and `libm-test`

Author: tgross35

crates/libm-macros/src/enums.rs

@@ -5,7 +5,7 @@ use quote::quote;
 use syn::spanned::Spanned;
 use syn::{Fields, ItemEnum, Variant};
 
-use crate::{ALL_FUNCTIONS_FLAT, base_name};
+use crate::{ALL_OPERATIONS, base_name};
 
 /// Implement `#[function_enum]`, see documentation in `lib.rs`.
 pub fn function_enum(
@@ -31,15 +31,17 @@ pub fn function_enum(
 
     let enum_name = &item.ident;
     let mut as_str_arms = Vec::new();
+    let mut from_str_arms = Vec::new();
     let mut base_arms = Vec::new();
 
-    for func in ALL_FUNCTIONS_FLAT.iter() {
+    for func in ALL_OPERATIONS.iter() {
         let fn_name = func.name;
         let ident = Ident::new(&fn_name.to_upper_camel_case(), Span::call_site());
         let bname_ident = Ident::new(&base_name(fn_name).to_upper_camel_case(), Span::call_site());
 
         // Match arm for `fn as_str(self)` matcher
         as_str_arms.push(quote! { Self::#ident => #fn_name });
+        from_str_arms.push(quote! { #fn_name => Self::#ident });
 
         // Match arm for `fn base_name(self)` matcher
         base_arms.push(quote! { Self::#ident => #base_enum::#bname_ident });
@@ -50,24 +52,45 @@ pub fn function_enum(
         item.variants.push(variant);
     }
 
+    let variants = item.variants.iter();
+
     let res = quote! {
         // Instantiate the enum
         #item
 
         impl #enum_name {
+            /// All variants of this enum.
+            pub const ALL: &[Self] = &[
+                #( Self::#variants, )*
+            ];
+
             /// The stringified version of this function name.
             pub const fn as_str(self) -> &'static str {
                 match self {
                     #( #as_str_arms , )*
                 }
             }
 
+            /// If `s` is the name of a function, return it.
+            pub fn from_str(s: &str) -> Option<Self> {
+                let ret = match s {
+                    #( #from_str_arms , )*
+                    _ => return None,
+                };
+                Some(ret)
+            }
+
             /// The base name enum for this function.
             pub const fn base_name(self) -> #base_enum {
                 match self {
                     #( #base_arms, )*
                 }
             }
+
+            /// Return information about this operation.
+            pub fn math_op(self) -> &'static crate::op::MathOpInfo {
+                crate::op::ALL_OPERATIONS.iter().find(|op| op.name == self.as_str()).unwrap()
+            }
         }
     };
 
@@ -85,8 +108,7 @@ pub fn base_name_enum(
         return Err(syn::Error::new(sp.span(), "no attributes expected"));
     }
 
-    let mut base_names: Vec<_> =
-        ALL_FUNCTIONS_FLAT.iter().map(|func| base_name(func.name)).collect();
+    let mut base_names: Vec<_> = ALL_OPERATIONS.iter().map(|func| base_name(func.name)).collect();
     base_names.sort_unstable();
     base_names.dedup();