Run `cargo fmt` on all projects

Apply the same formatting rules to both `libm` and `compiler-builtins`.

4 files changed, 228 insertions, 60 deletions

diff --git a/library/compiler-builtins/crates/libm-macros/src/enums.rs b/library/compiler-builtins/crates/libm-macros/src/enums.rs
index 864b625eab3..b4646f984d4 100644
--- a/library/compiler-builtins/crates/libm-macros/src/enums.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/enums.rs
@@ -26,7 +26,10 @@ pub fn function_enum(
     };
 
     if let Some(tt) = attr.next() {
-        return Err(syn::Error::new(tt.span(), "unexpected token after identifier"));
+        return Err(syn::Error::new(
+            tt.span(),
+            "unexpected token after identifier",
+        ));
     }
 
     let enum_name = &item.ident;
@@ -46,8 +49,12 @@ pub fn function_enum(
         // Match arm for `fn base_name(self)` matcher
         base_arms.push(quote! { Self::#ident => #base_enum::#bname_ident });
 
-        let variant =
-            Variant { attrs: Vec::new(), ident, fields: Fields::Unit, discriminant: None };
+        let variant = Variant {
+            attrs: Vec::new(),
+            ident,
+            fields: Fields::Unit,
+            discriminant: None,
+        };
 
         item.variants.push(variant);
     }
@@ -108,7 +115,10 @@ pub fn base_name_enum(
         return Err(syn::Error::new(sp.span(), "no attributes expected"));
     }
 
-    let mut base_names: Vec<_> = ALL_OPERATIONS.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();
 
@@ -121,8 +131,12 @@ pub fn base_name_enum(
         // Match arm for `fn as_str(self)` matcher
         as_str_arms.push(quote! { Self::#ident => #base_name });
 
-        let variant =
-            Variant { attrs: Vec::new(), ident, fields: Fields::Unit, discriminant: None };
+        let variant = Variant {
+            attrs: Vec::new(),
+            ident,
+            fields: Fields::Unit,
+            discriminant: None,
+        };
 
         item.variants.push(variant);
     }
@@ -147,7 +161,10 @@ pub fn base_name_enum(
 /// Verify that an enum is empty, otherwise return an error
 fn expect_empty_enum(item: &ItemEnum) -> syn::Result<()> {
     if !item.variants.is_empty() {
-        Err(syn::Error::new(item.variants.span(), "expected an empty enum"))
+        Err(syn::Error::new(
+            item.variants.span(),
+            "expected an empty enum",
+        ))
     } else {
         Ok(())
     }
diff --git a/library/compiler-builtins/crates/libm-macros/src/lib.rs b/library/compiler-builtins/crates/libm-macros/src/lib.rs
index 3cee5385b62..3cdd364e830 100644
--- a/library/compiler-builtins/crates/libm-macros/src/lib.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/lib.rs
@@ -11,7 +11,9 @@ use syn::spanned::Spanned;
 use syn::visit_mut::VisitMut;
 use syn::{Ident, ItemEnum};
 
-const KNOWN_TYPES: &[&str] = &["FTy", "CFn", "CArgs", "CRet", "RustFn", "RustArgs", "RustRet"];
+const KNOWN_TYPES: &[&str] = &[
+    "FTy", "CFn", "CArgs", "CRet", "RustFn", "RustArgs", "RustRet",
+];
 
 /// Populate an enum with a variant representing function. Names are in upper camel case.
 ///
@@ -142,10 +144,17 @@ fn validate(input: &mut StructuredInput) -> syn::Result<Vec<&'static MathOpInfo>
         .flat_map(|map_list| map_list.iter())
         .flat_map(|attr_map| attr_map.names.iter());
     let only_mentions = input.only.iter().flat_map(|only_list| only_list.iter());
-    let fn_extra_mentions =
-        input.fn_extra.iter().flat_map(|v| v.keys()).filter(|name| *name != "_");
-    let all_mentioned_fns =
-        input.skip.iter().chain(only_mentions).chain(attr_mentions).chain(fn_extra_mentions);
+    let fn_extra_mentions = input
+        .fn_extra
+        .iter()
+        .flat_map(|v| v.keys())
+        .filter(|name| *name != "_");
+    let all_mentioned_fns = input
+        .skip
+        .iter()
+        .chain(only_mentions)
+        .chain(attr_mentions)
+        .chain(fn_extra_mentions);
 
     // Make sure that every function mentioned is a real function
     for mentioned in all_mentioned_fns {
@@ -171,7 +180,11 @@ fn validate(input: &mut StructuredInput) -> syn::Result<Vec<&'static MathOpInfo>
     for func in ALL_OPERATIONS.iter() {
         let fn_name = func.name;
         // If we have an `only` list and it does _not_ contain this function name, skip it
-        if input.only.as_ref().is_some_and(|only| !only.iter().any(|o| o == fn_name)) {
+        if input
+            .only
+            .as_ref()
+            .is_some_and(|only| !only.iter().any(|o| o == fn_name))
+        {
             continue;
         }
 
@@ -296,8 +309,11 @@ fn expand(input: StructuredInput, fn_list: &[&MathOpInfo]) -> syn::Result<pm2::T
         // Prepare function-specific extra in a `fn_extra: ...` field, running the replacer
         let fn_extra_field = match input.fn_extra {
             Some(ref map) => {
-                let mut fn_extra =
-                    map.get(&fn_name).or_else(|| map.get(&default_ident)).unwrap().clone();
+                let mut fn_extra = map
+                    .get(&fn_name)
+                    .or_else(|| map.get(&default_ident))
+                    .unwrap()
+                    .clone();
 
                 let mut v = MacroReplace::new(func.name);
                 v.visit_expr_mut(&mut fn_extra);
@@ -357,7 +373,11 @@ struct MacroReplace {
 impl MacroReplace {
     fn new(name: &'static str) -> Self {
         let norm_name = base_name(name);
-        Self { fn_name: name, norm_name: norm_name.to_owned(), error: None }
+        Self {
+            fn_name: name,
+            norm_name: norm_name.to_owned(),
+            error: None,
+        }
     }
 
     fn finish(self) -> syn::Result<()> {
@@ -377,8 +397,10 @@ impl MacroReplace {
             "MACRO_FN_NAME" => *i = Ident::new(self.fn_name, i.span()),
             "MACRO_FN_NAME_NORMALIZED" => *i = Ident::new(&self.norm_name, i.span()),
             _ => {
-                self.error =
-                    Some(syn::Error::new(i.span(), format!("unrecognized meta expression `{s}`")));
+                self.error = Some(syn::Error::new(
+                    i.span(),
+                    format!("unrecognized meta expression `{s}`"),
+                ));
             }
         }
     }
diff --git a/library/compiler-builtins/crates/libm-macros/src/parse.rs b/library/compiler-builtins/crates/libm-macros/src/parse.rs
index 369bbae2f4f..d60d1247a9e 100644
--- a/library/compiler-builtins/crates/libm-macros/src/parse.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/parse.rs
@@ -16,7 +16,9 @@ pub struct Invocation {
 
 impl Parse for Invocation {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        Ok(Self { fields: input.parse_terminated(Mapping::parse, Token![,])? })
+        Ok(Self {
+            fields: input.parse_terminated(Mapping::parse, Token![,])?,
+        })
     }
 }
 
@@ -30,7 +32,11 @@ struct Mapping {
 
 impl Parse for Mapping {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        Ok(Self { name: input.parse()?, _sep: input.parse()?, expr: input.parse()? })
+        Ok(Self {
+            name: input.parse()?,
+            _sep: input.parse()?,
+            expr: input.parse()?,
+        })
     }
 }
 
@@ -133,7 +139,13 @@ fn extract_fn_extra_field(expr: Expr) -> syn::Result<BTreeMap<Ident, Expr>> {
         return Err(e);
     };
 
-    let ExprMatch { attrs, match_token: _, expr, brace_token: _, arms } = mexpr;
+    let ExprMatch {
+        attrs,
+        match_token: _,
+        expr,
+        brace_token: _,
+        arms,
+    } = mexpr;
 
     expect_empty_attrs(&attrs)?;
 
@@ -146,7 +158,14 @@ fn extract_fn_extra_field(expr: Expr) -> syn::Result<BTreeMap<Ident, Expr>> {
     let mut res = BTreeMap::new();
 
     for arm in arms {
-        let Arm { attrs, pat, guard, fat_arrow_token: _, body, comma: _ } = arm;
+        let Arm {
+            attrs,
+            pat,
+            guard,
+            fat_arrow_token: _,
+            body,
+            comma: _,
+        } = arm;
 
         expect_empty_attrs(&attrs)?;
 
@@ -177,15 +196,20 @@ fn expect_empty_attrs(attrs: &[Attribute]) -> syn::Result<()> {
         return Ok(());
     }
 
-    let e =
-        syn::Error::new(attrs.first().unwrap().span(), "no attributes allowed in this position");
+    let e = syn::Error::new(
+        attrs.first().unwrap().span(),
+        "no attributes allowed in this position",
+    );
     Err(e)
 }
 
 /// Extract a named field from a map, raising an error if it doesn't exist.
 fn expect_field(v: &mut Vec<Mapping>, name: &str) -> syn::Result<Expr> {
     let pos = v.iter().position(|v| v.name == name).ok_or_else(|| {
-        syn::Error::new(Span::call_site(), format!("missing expected field `{name}`"))
+        syn::Error::new(
+            Span::call_site(),
+            format!("missing expected field `{name}`"),
+        )
     })?;
 
     Ok(v.remove(pos).expr)
diff --git a/library/compiler-builtins/crates/libm-macros/src/shared.rs b/library/compiler-builtins/crates/libm-macros/src/shared.rs
index 5e58220eb39..750ed1afb05 100644
--- a/library/compiler-builtins/crates/libm-macros/src/shared.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/shared.rs
@@ -7,7 +7,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `fn(f16) -> f16`
         FloatTy::F16,
-        Signature { args: &[Ty::F16], returns: &[Ty::F16] },
+        Signature {
+            args: &[Ty::F16],
+            returns: &[Ty::F16],
+        },
         None,
         &[
             "ceilf16",
@@ -23,7 +26,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `fn(f32) -> f32`
         FloatTy::F32,
-        Signature { args: &[Ty::F32], returns: &[Ty::F32] },
+        Signature {
+            args: &[Ty::F32],
+            returns: &[Ty::F32],
+        },
         None,
         &[
             "acosf",
@@ -68,7 +74,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f64) -> f64`
         FloatTy::F64,
-        Signature { args: &[Ty::F64], returns: &[Ty::F64] },
+        Signature {
+            args: &[Ty::F64],
+            returns: &[Ty::F64],
+        },
         None,
         &[
             "acos",
@@ -113,7 +122,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `fn(f128) -> f128`
         FloatTy::F128,
-        Signature { args: &[Ty::F128], returns: &[Ty::F128] },
+        Signature {
+            args: &[Ty::F128],
+            returns: &[Ty::F128],
+        },
         None,
         &[
             "ceilf128",
@@ -129,7 +141,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f16, f16) -> f16`
         FloatTy::F16,
-        Signature { args: &[Ty::F16, Ty::F16], returns: &[Ty::F16] },
+        Signature {
+            args: &[Ty::F16, Ty::F16],
+            returns: &[Ty::F16],
+        },
         None,
         &[
             "copysignf16",
@@ -146,7 +161,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f32, f32) -> f32`
         FloatTy::F32,
-        Signature { args: &[Ty::F32, Ty::F32], returns: &[Ty::F32] },
+        Signature {
+            args: &[Ty::F32, Ty::F32],
+            returns: &[Ty::F32],
+        },
         None,
         &[
             "atan2f",
@@ -168,7 +186,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f64, f64) -> f64`
         FloatTy::F64,
-        Signature { args: &[Ty::F64, Ty::F64], returns: &[Ty::F64] },
+        Signature {
+            args: &[Ty::F64, Ty::F64],
+            returns: &[Ty::F64],
+        },
         None,
         &[
             "atan2",
@@ -190,7 +211,10 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f128, f128) -> f128`
         FloatTy::F128,
-        Signature { args: &[Ty::F128, Ty::F128], returns: &[Ty::F128] },
+        Signature {
+            args: &[Ty::F128, Ty::F128],
+            returns: &[Ty::F128],
+        },
         None,
         &[
             "copysignf128",
@@ -207,134 +231,215 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
     (
         // `(f32, f32, f32) -> f32`
         FloatTy::F32,
-        Signature { args: &[Ty::F32, Ty::F32, Ty::F32], returns: &[Ty::F32] },
+        Signature {
+            args: &[Ty::F32, Ty::F32, Ty::F32],
+            returns: &[Ty::F32],
+        },
         None,
         &["fmaf"],
     ),
     (
         // `(f64, f64, f64) -> f64`
         FloatTy::F64,
-        Signature { args: &[Ty::F64, Ty::F64, Ty::F64], returns: &[Ty::F64] },
+        Signature {
+            args: &[Ty::F64, Ty::F64, Ty::F64],
+            returns: &[Ty::F64],
+        },
         None,
         &["fma"],
     ),
     (
         // `(f128, f128, f128) -> f128`
         FloatTy::F128,
-        Signature { args: &[Ty::F128, Ty::F128, Ty::F128], returns: &[Ty::F128] },
+        Signature {
+            args: &[Ty::F128, Ty::F128, Ty::F128],
+            returns: &[Ty::F128],
+        },
         None,
         &["fmaf128"],
     ),
     (
         // `(f32) -> i32`
         FloatTy::F32,
-        Signature { args: &[Ty::F32], returns: &[Ty::I32] },
+        Signature {
+            args: &[Ty::F32],
+            returns: &[Ty::I32],
+        },
         None,
         &["ilogbf"],
     ),
     (
         // `(f64) -> i32`
         FloatTy::F64,
-        Signature { args: &[Ty::F64], returns: &[Ty::I32] },
+        Signature {
+            args: &[Ty::F64],
+            returns: &[Ty::I32],
+        },
         None,
         &["ilogb"],
     ),
     (
         // `(i32, f32) -> f32`
         FloatTy::F32,
-        Signature { args: &[Ty::I32, Ty::F32], returns: &[Ty::F32] },
+        Signature {
+            args: &[Ty::I32, Ty::F32],
+            returns: &[Ty::F32],
+        },
         None,
         &["jnf", "ynf"],
     ),
     (
         // `(i32, f64) -> f64`
         FloatTy::F64,
-        Signature { args: &[Ty::I32, Ty::F64], returns: &[Ty::F64] },
+        Signature {
+            args: &[Ty::I32, Ty::F64],
+            returns: &[Ty::F64],
+        },
         None,
         &["jn", "yn"],
     ),
     (
         // `(f16, i32) -> f16`
         FloatTy::F16,
-        Signature { args: &[Ty::F16, Ty::I32], returns: &[Ty::F16] },
+        Signature {
+            args: &[Ty::F16, Ty::I32],
+            returns: &[Ty::F16],
+        },
         None,
         &["ldexpf16", "scalbnf16"],
     ),
     (
         // `(f32, i32) -> f32`
         FloatTy::F32,
-        Signature { args: &[Ty::F32, Ty::I32], returns: &[Ty::F32] },
+        Signature {
+            args: &[Ty::F32, Ty::I32],
+            returns: &[Ty::F32],
+        },
         None,
         &["ldexpf", "scalbnf"],
     ),
     (
         // `(f64, i64) -> f64`
         FloatTy::F64,
-        Signature { args: &[Ty::F64, Ty::I32], returns: &[Ty::F64] },
+        Signature {
+            args: &[Ty::F64, Ty::I32],
+            returns: &[Ty::F64],
+        },
         None,
         &["ldexp", "scalbn"],
     ),
     (
         // `(f128, i32) -> f128`
         FloatTy::F128,
-        Signature { args: &[Ty::F128, Ty::I32], returns: &[Ty::F128] },
+        Signature {
+            args: &[Ty::F128, Ty::I32],
+            returns: &[Ty::F128],
+        },
         None,
         &["ldexpf128", "scalbnf128"],
     ),
     (
         // `(f32, &mut f32) -> f32` as `(f32) -> (f32, f32)`
         FloatTy::F32,
-        Signature { args: &[Ty::F32], returns: &[Ty::F32, Ty::F32] },
-        Some(Signature { args: &[Ty::F32, Ty::MutF32], returns: &[Ty::F32] }),
+        Signature {
+            args: &[Ty::F32],
+            returns: &[Ty::F32, Ty::F32],
+        },
+        Some(Signature {
+            args: &[Ty::F32, Ty::MutF32],
+            returns: &[Ty::F32],
+        }),
         &["modff"],
     ),
     (
         // `(f64, &mut f64) -> f64` as  `(f64) -> (f64, f64)`
         FloatTy::F64,
-        Signature { args: &[Ty::F64], returns: &[Ty::F64, Ty::F64] },
-        Some(Signature { args: &[Ty::F64, Ty::MutF64], returns: &[Ty::F64] }),
+        Signature {
+            args: &[Ty::F64],
+            returns: &[Ty::F64, Ty::F64],
+        },
+        Some(Signature {
+            args: &[Ty::F64, Ty::MutF64],
+            returns: &[Ty::F64],
+        }),
         &["modf"],
     ),
     (
         // `(f32, &mut c_int) -> f32` as `(f32) -> (f32, i32)`
         FloatTy::F32,
-        Signature { args: &[Ty::F32], returns: &[Ty::F32, Ty::I32] },
-        Some(Signature { args: &[Ty::F32, Ty::MutCInt], returns: &[Ty::F32] }),
+        Signature {
+            args: &[Ty::F32],
+            returns: &[Ty::F32, Ty::I32],
+        },
+        Some(Signature {
+            args: &[Ty::F32, Ty::MutCInt],
+            returns: &[Ty::F32],
+        }),
         &["frexpf", "lgammaf_r"],
     ),
     (
         // `(f64, &mut c_int) -> f64` as `(f64) -> (f64, i32)`
         FloatTy::F64,
-        Signature { args: &[Ty::F64], returns: &[Ty::F64, Ty::I32] },
-        Some(Signature { args: &[Ty::F64, Ty::MutCInt], returns: &[Ty::F64] }),
+        Signature {
+            args: &[Ty::F64],
+            returns: &[Ty::F64, Ty::I32],
+        },
+        Some(Signature {
+            args: &[Ty::F64, Ty::MutCInt],
+            returns: &[Ty::F64],
+        }),
         &["frexp", "lgamma_r"],
     ),
     (
         // `(f32, f32, &mut c_int) -> f32` as `(f32, f32) -> (f32, i32)`
         FloatTy::F32,
-        Signature { args: &[Ty::F32, Ty::F32], returns: &[Ty::F32, Ty::I32] },
-        Some(Signature { args: &[Ty::F32, Ty::F32, Ty::MutCInt], returns: &[Ty::F32] }),
+        Signature {
+            args: &[Ty::F32, Ty::F32],
+            returns: &[Ty::F32, Ty::I32],
+        },
+        Some(Signature {
+            args: &[Ty::F32, Ty::F32, Ty::MutCInt],
+            returns: &[Ty::F32],
+        }),
         &["remquof"],
     ),
     (
         // `(f64, f64, &mut c_int) -> f64` as `(f64, f64) -> (f64, i32)`
         FloatTy::F64,
-        Signature { args: &[Ty::F64, Ty::F64], returns: &[Ty::F64, Ty::I32] },
-        Some(Signature { args: &[Ty::F64, Ty::F64, Ty::MutCInt], returns: &[Ty::F64] }),
+        Signature {
+            args: &[Ty::F64, Ty::F64],
+            returns: &[Ty::F64, Ty::I32],
+        },
+        Some(Signature {
+            args: &[Ty::F64, Ty::F64, Ty::MutCInt],
+            returns: &[Ty::F64],
+        }),
         &["remquo"],
     ),
     (
         // `(f32, &mut f32, &mut f32)` as `(f32) -> (f32, f32)`
         FloatTy::F32,
-        Signature { args: &[Ty::F32], returns: &[Ty::F32, Ty::F32] },
-        Some(Signature { args: &[Ty::F32, Ty::MutF32, Ty::MutF32], returns: &[] }),
+        Signature {
+            args: &[Ty::F32],
+            returns: &[Ty::F32, Ty::F32],
+        },
+        Some(Signature {
+            args: &[Ty::F32, Ty::MutF32, Ty::MutF32],
+            returns: &[],
+        }),
         &["sincosf"],
     ),
     (
         // `(f64, &mut f64, &mut f64)` as `(f64) -> (f64, f64)`
         FloatTy::F64,
-        Signature { args: &[Ty::F64], returns: &[Ty::F64, Ty::F64] },
-        Some(Signature { args: &[Ty::F64, Ty::MutF64, Ty::MutF64], returns: &[] }),
+        Signature {
+            args: &[Ty::F64],
+            returns: &[Ty::F64, Ty::F64],
+        },
+        Some(Signature {
+            args: &[Ty::F64, Ty::MutF64, Ty::MutF64],
+            returns: &[],
+        }),
         &["sincos"],
     ),
 ];