Enforce uninlined_format_args for the workspace (bytecodealliance#9065)

* Enforce `uninlined_format_args` for the workspace

* fix: failing `Monolith Checks` job

* fix: formatting

Author: hamirmahal

Cargo.toml

@@ -178,6 +178,7 @@ unused-lifetimes = 'warn'
 all = { level = 'allow', priority = -1 }
 clone_on_copy = 'warn'
 map_clone = 'warn'
+uninlined_format_args = 'warn'
 unnecessary_to_owned = 'warn'
 manual_strip = 'warn'
 

cranelift/bforest/src/node.rs

@@ -174,7 +174,7 @@ impl<F: Forest> NodeData<F> {
             } => {
                 let sz = usize::from(*size);
                 debug_assert!(sz <= keys.len());
-                debug_assert!(index <= sz, "Can't insert at {} with {} keys", index, sz);
+                debug_assert!(index <= sz, "Can't insert at {index} with {sz} keys");
 
                 if let Some(ks) = keys.get_mut(0..=sz) {
                     *size = (sz + 1) as u8;
@@ -547,7 +547,7 @@ impl ValDisp for SetValue {
 
 impl<T: fmt::Display> ValDisp for T {
     fn valfmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, ":{}", self)
+        write!(f, ":{self}")
     }
 }
 
@@ -576,7 +576,7 @@ where
                 }
                 write!(f, " ]")
             }
-            Self::Free { next: Some(n) } => write!(f, "[ free -> {} ]", n),
+            Self::Free { next: Some(n) } => write!(f, "[ free -> {n} ]"),
             Self::Free { next: None } => write!(f, "[ free ]"),
         }
     }
@@ -641,7 +641,7 @@ mod tests {
 
         // Splitting should be independent of the hint because we have an even number of node
         // references.
-        let saved = inner.clone();
+        let saved = inner;
         let sp = inner.split(1);
         assert_eq!(sp.lhs_entries, 4);
         assert_eq!(sp.rhs_entries, 4);
@@ -691,7 +691,7 @@ mod tests {
         assert!(!leaf.try_leaf_insert(15, 'x', SetValue()));
 
         // The index given to `split` is not the split position, it's a hint for balancing the node.
-        let saved = leaf.clone();
+        let saved = leaf;
         let sp = leaf.split(12);
         assert_eq!(sp.lhs_entries, 8);
         assert_eq!(sp.rhs_entries, 7);

cranelift/bforest/src/path.rs

@@ -651,11 +651,7 @@ impl<F: Forest> Path<F> {
         for level in 0..self.size {
             match pool[self.node[level]] {
                 NodeData::Inner { size, tree, .. } => {
-                    assert!(
-                        level < self.size - 1,
-                        "Expected leaf node at level {}",
-                        level
-                    );
+                    assert!(level < self.size - 1, "Expected leaf node at level {level}");
                     assert!(
                         self.entry[level] <= size,
                         "OOB inner entry {}/{} at level {}",
@@ -666,8 +662,7 @@ impl<F: Forest> Path<F> {
                     assert_eq!(
                         self.node[level + 1],
                         tree[usize::from(self.entry[level])],
-                        "Node mismatch at level {}",
-                        level
+                        "Node mismatch at level {level}"
                     );
                 }
                 NodeData::Leaf { size, .. } => {

cranelift/bforest/src/pool.rs

@@ -52,7 +52,7 @@ impl<F: Forest> NodePool<F> {
     /// Free a node.
     pub fn free_node(&mut self, node: Node) {
         // Quick check for a double free.
-        debug_assert!(!self.nodes[node].is_free(), "{} is already free", node);
+        debug_assert!(!self.nodes[node].is_free(), "{node} is already free");
         self.nodes[node] = NodeData::Free {
             next: self.freelist,
         };
@@ -162,7 +162,7 @@ impl<F: Forest> NodePool<F> {
 
                     // Verify occupancy.
                     // Right-most nodes can be small, but others must be at least half full.
-                    assert!(size > 0, "Leaf {} is empty", node);
+                    assert!(size > 0, "Leaf {node} is empty");
                     assert!(
                         rkey.is_none() || size * 2 >= capacity,
                         "Only {}/{} entries in {}:{}, upper={}",

cranelift/codegen/build.rs

@@ -48,7 +48,7 @@ fn main() {
         // Try to match native target.
         let target_name = target_triple.split('-').next().unwrap();
         let isa = meta::isa_from_arch(&target_name).expect("error when identifying target");
-        println!("cargo:rustc-cfg=feature=\"{}\"", isa);
+        println!("cargo:rustc-cfg=feature=\"{isa}\"");
         isas.push(isa);
     }
 
@@ -82,13 +82,13 @@ fn main() {
     }
 
     if let Err(err) = meta::generate(&isas, &out_dir, isle_dir) {
-        eprintln!("Error: {}", err);
+        eprintln!("Error: {err}");
         process::exit(1);
     }
 
     if &std::env::var("SKIP_ISLE").unwrap_or("0".to_string()) != "1" {
         if let Err(err) = build_isle(crate_dir, isle_dir) {
-            eprintln!("Error: {}", err);
+            eprintln!("Error: {err}");
             process::exit(1);
         }
     }
@@ -121,7 +121,7 @@ fn main() {
         let status = child.wait().unwrap();
         if status.success() {
             let git_rev = git_rev.trim().chars().take(9).collect::<String>();
-            format!("{}-{}", pkg_version, git_rev)
+            format!("{pkg_version}-{git_rev}")
         } else {
             // not a git repo
             pkg_version
@@ -134,8 +134,7 @@ fn main() {
         std::path::Path::new(&out_dir).join("version.rs"),
         format!(
             "/// Version number of this crate. \n\
-            pub const VERSION: &str = \"{}\";",
-            version
+            pub const VERSION: &str = \"{version}\";"
         ),
     )
     .unwrap();
@@ -174,7 +173,7 @@ fn build_isle(
         if let Err(e) = run_compilation(compilation) {
             had_error = true;
             eprintln!("Error building ISLE files:");
-            eprintln!("{:?}", e);
+            eprintln!("{e:?}");
             #[cfg(not(feature = "isle-errors"))]
             {
                 eprintln!("To see a more detailed error report, run: ");
@@ -221,10 +220,7 @@ fn run_compilation(compilation: &IsleCompilation) -> Result<(), Errors> {
     };
 
     let code = rustfmt(&code).unwrap_or_else(|e| {
-        println!(
-            "cargo:warning=Failed to run `rustfmt` on ISLE-generated code: {:?}",
-            e
-        );
+        println!("cargo:warning=Failed to run `rustfmt` on ISLE-generated code: {e:?}");
         code
     });
 
@@ -258,7 +254,7 @@ fn rustfmt(code: &str) -> std::io::Result<String> {
     if !status.success() {
         return Err(std::io::Error::new(
             std::io::ErrorKind::Other,
-            format!("`rustfmt` exited with status {}", status),
+            format!("`rustfmt` exited with status {status}"),
         ));
     }
 

cranelift/codegen/meta/src/cdsl/settings.rs

@@ -189,7 +189,7 @@ impl PredicateNode {
                 group.name, group.settings[bool_setting_index.0].name
             ),
             PredicateNode::SharedBool(ref group_name, ref bool_name) => {
-                format!("{}.{}()", group_name, bool_name)
+                format!("{group_name}.{bool_name}()")
             }
             PredicateNode::And(ref lhs, ref rhs) => {
                 format!("{} && {}", lhs.render(group), rhs.render(group))

cranelift/codegen/meta/src/cdsl/types.rs

@@ -242,8 +242,8 @@ impl fmt::Debug for LaneType {
             f,
             "{}",
             match *self {
-                LaneType::Float(_) => format!("FloatType({})", inner_msg),
-                LaneType::Int(_) => format!("IntType({})", inner_msg),
+                LaneType::Float(_) => format!("FloatType({inner_msg})"),
+                LaneType::Int(_) => format!("IntType({inner_msg})"),
             }
         )
     }

cranelift/codegen/meta/src/error.rs

@@ -41,8 +41,8 @@ enum ErrorInner {
 impl fmt::Display for ErrorInner {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ErrorInner::Msg(ref s) => write!(f, "{}", s),
-            ErrorInner::IoError(ref e) => write!(f, "{}", e),
+            ErrorInner::Msg(ref s) => write!(f, "{s}"),
+            ErrorInner::IoError(ref e) => write!(f, "{e}"),
         }
     }
 }

cranelift/codegen/meta/src/gen_inst.rs

@@ -92,7 +92,7 @@ fn gen_instruction_data(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter)
                         "blocks: [ir::BlockCall; {}],",
                         format.num_block_operands
                     ),
-                    n => panic!("Too many block operands in instruction: {}", n),
+                    n => panic!("Too many block operands in instruction: {n}"),
                 }
 
                 for field in &format.imm_fields {
@@ -137,21 +137,21 @@ fn gen_arguments_method(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter,
                 m.arm(
                     name,
                     vec![format!("ref {}args", mut_), "..".to_string()],
-                    format!("args.{}(pool)", as_slice),
+                    format!("args.{as_slice}(pool)"),
                 );
                 continue;
             }
 
             // Fixed args.
             let mut fields = Vec::new();
             let arg = if format.num_value_operands == 0 {
-                format!("&{}[]", mut_)
+                format!("&{mut_}[]")
             } else if format.num_value_operands == 1 {
-                fields.push(format!("ref {}arg", mut_));
-                format!("{}(arg)", rslice)
+                fields.push(format!("ref {mut_}arg"));
+                format!("{rslice}(arg)")
             } else {
                 let arg = format!("args_arity{}", format.num_value_operands);
-                fields.push(format!("args: ref {}{}", mut_, arg));
+                fields.push(format!("args: ref {mut_}{arg}"));
                 arg
             };
             fields.push("..".into());
@@ -277,8 +277,8 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         members.push(field.member);
                     }
 
-                    let pat1 = members.iter().map(|x| format!("{}: ref {}1", x, x)).collect::<Vec<_>>().join(", ");
-                    let pat2 = members.iter().map(|x| format!("{}: ref {}2", x, x)).collect::<Vec<_>>().join(", ");
+                    let pat1 = members.iter().map(|x| format!("{x}: ref {x}1")).collect::<Vec<_>>().join(", ");
+                    let pat2 = members.iter().map(|x| format!("{x}: ref {x}2")).collect::<Vec<_>>().join(", ");
                     fmtln!(fmt, "({} {{ {} }}, {} {{ {} }}) => {{", name, pat1, name, pat2);
                     fmt.indent(|fmt| {
                         fmt.line("opcode1 == opcode2");
@@ -734,7 +734,7 @@ fn iterable_to_string<I: fmt::Display, T: IntoIterator<Item = I>>(iterable: T) -
         .map(|x| x.to_string())
         .collect::<Vec<_>>()
         .join(", ");
-    format!("{{{}}}", elems)
+    format!("{{{elems}}}")
 }
 
 fn typeset_to_string(ts: &TypeSet) -> String {
@@ -853,7 +853,7 @@ fn gen_type_constraints(all_inst: &AllInstructions, fmt: &mut Formatter) {
             );
             fmt.comment(format!("Constraints=[{}]", constraints
                 .iter()
-                .map(|x| format!("'{}'", x))
+                .map(|x| format!("'{x}'"))
                 .collect::<Vec<_>>()
                 .join(", ")));
             if let Some(poly) = &inst.polymorphic_info {
@@ -916,7 +916,7 @@ fn gen_member_inits(format: &InstructionFormat, fmt: &mut Formatter) {
     } else if format.num_value_operands > 1 {
         let mut args = Vec::new();
         for i in 0..format.num_value_operands {
-            args.push(format!("arg{}", i));
+            args.push(format!("arg{i}"));
         }
         fmtln!(fmt, "args: [{}],", args.join(", "));
     }
@@ -928,7 +928,7 @@ fn gen_member_inits(format: &InstructionFormat, fmt: &mut Formatter) {
         n => {
             let mut blocks = Vec::new();
             for i in 0..n {
-                blocks.push(format!("block{}", i));
+                blocks.push(format!("block{i}"));
             }
             fmtln!(fmt, "blocks: [{}],", blocks.join(", "));
         }
@@ -953,7 +953,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
     }
 
     // Then the block operands.
-    args.extend((0..format.num_block_operands).map(|i| format!("block{}: ir::BlockCall", i)));
+    args.extend((0..format.num_block_operands).map(|i| format!("block{i}: ir::BlockCall")));
 
     // Then the value operands.
     if format.has_value_list {
@@ -963,7 +963,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
     } else {
         // Take a fixed number of value operands.
         for i in 0..format.num_value_operands {
-            args.push(format!("arg{}: Value", i));
+            args.push(format!("arg{i}: Value"));
         }
     }
 
@@ -1000,7 +1000,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
         }
 
         // Assert that this opcode belongs to this format
-        fmtln!(fmt, "debug_assert_eq!(opcode.format(), InstructionFormat::from(&data), \"Wrong InstructionFormat for Opcode: {}\", opcode);");
+        fmtln!(fmt, "debug_assert_eq!(opcode.format(), InstructionFormat::from(&data), \"Wrong InstructionFormat for Opcode: {opcode}\");");
 
         fmt.line("self.build(data, ctrl_typevar)");
     });
@@ -1202,7 +1202,7 @@ fn gen_inst_builder(inst: &Instruction, format: &InstructionFormat, fmt: &mut Fo
                 inst.value_results
                     .iter()
                     .enumerate()
-                    .map(|(i, _)| format!("results[{}]", i))
+                    .map(|(i, _)| format!("results[{i}]"))
                     .collect::<Vec<_>>()
                     .join(", ")
             );

cranelift/codegen/meta/src/gen_isle.rs

@@ -182,7 +182,7 @@ fn gen_common_isle(
                 match format.num_block_operands {
                     0 => (),
                     1 => write!(&mut s, " (destination BlockCall)").unwrap(),
-                    n => write!(&mut s, " (blocks BlockArray{})", n).unwrap(),
+                    n => write!(&mut s, " (blocks BlockArray{n})").unwrap(),
                 }
 
                 for field in &format.imm_fields {
@@ -289,7 +289,7 @@ fn gen_common_isle(
                     .unwrap()
                     .name;
                 if values.is_empty() {
-                    write!(&mut s, " (value_list_slice {})", varargs).unwrap();
+                    write!(&mut s, " (value_list_slice {varargs})").unwrap();
                 } else {
                     write!(
                         &mut s,
@@ -481,7 +481,7 @@ fn gen_lower_isle(
 /// Generate an `enum` immediate in ISLE.
 fn gen_isle_enum(name: &str, mut variants: Vec<&str>, fmt: &mut Formatter) {
     variants.sort();
-    let prefix = format!(";;;; Enumerated Immediate: {} ", name);
+    let prefix = format!(";;;; Enumerated Immediate: {name} ");
     fmtln!(fmt, "{:;<80}", prefix);
     fmt.empty_line();
     fmtln!(fmt, "(type {} extern", name);