Copy lint settings from Wasmtime (#2156)

* Copy lint settings from Wasmtime

Then use `--fix` to apply auto-suggested fixes everywhere.

* Fix lint warning

* More lint fixes

Author: alexcrichton

Cargo.toml

@@ -46,6 +46,24 @@ members = [
 
 [workspace.lints.rust]
 unsafe_code = "deny"
+# Turn on some lints which are otherwise allow-by-default in rustc.
+unused_extern_crates = 'warn'
+unstable_features = 'warn'
+unused_import_braces = 'warn'
+unused-lifetimes = 'warn'
+unused-macro-rules = 'warn'
+
+# Lints that are part of the `rust-2024-compatibility` group. This group is a
+# bit too noisy to enable wholesale but some selective items are ones we want to
+# opt-in to.
+keyword_idents_2024 = 'warn'
+unsafe-attr-outside-unsafe = 'warn'
+deprecated-safe-2024 = 'warn'
+rust-2024-guarded-string-incompatible-syntax = 'warn'
+rust-2024-prelude-collisions = 'warn'
+rust-2024-incompatible-pat = 'warn'
+missing-unsafe-on-extern = 'warn'
+unsafe-op-in-unsafe-fn = 'warn'
 
 [workspace.lints.clippy]
 # The default set of lints in Clippy is viewed as "too noisy" right now so
@@ -56,6 +74,11 @@ clone_on_copy = 'warn'
 map_clone = 'warn'
 unnecessary_to_owned = 'warn'
 manual_strip = 'warn'
+uninlined_format_args = 'warn'
+unnecessary_mut_passed = 'warn'
+unnecessary_fallible_conversions = 'warn'
+unnecessary_cast = 'warn'
+allow_attributes_without_reason = 'warn'
 
 [workspace.package]
 edition = '2021'

crates/c-api/src/lib.rs

@@ -26,7 +26,7 @@ pub enum wasm_tools_error {
 }
 use wasm_tools_error::*;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_tools_byte_vec_delete(bytes: &mut wasm_tools_byte_vec_t) {
     unsafe {
         Vec::from_raw_parts(bytes.data, bytes.size, bytes.size);
@@ -38,7 +38,7 @@ pub extern "C" fn wasm_tools_byte_vec_delete(bytes: &mut wasm_tools_byte_vec_t)
 /// # Safety
 ///
 /// `seed` must be a valid pointer to `seed_len` bytes of memory.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_smith_create(
     seed: *const u8,
     seed_len: usize,

crates/fuzz-stats/src/bin/failed-instantiations.rs

@@ -32,9 +32,7 @@ fn under_10_percent() {
     let bad = state.instantiate_trap.load(SeqCst) + state.instantiate_oom.load(SeqCst);
     assert!(
         bad < total / 10,
-        "{} modules failed to instantiate out of {}, this failure rate is too high",
-        bad,
-        total
+        "{bad} modules failed to instantiate out of {total}, this failure rate is too high"
     );
 }
 
@@ -79,7 +77,7 @@ impl State {
                         data.resize(cur + extra, 0);
                         rng.fill_bytes(&mut data[cur..]);
                     }
-                    Err(e) => panic!("failed to generated module: {}", e),
+                    Err(e) => panic!("failed to generated module: {e}"),
                 }
             }
         }
@@ -163,7 +161,7 @@ impl State {
                 // panic.
                 } else {
                     std::fs::write("panic.wasm", &wasm).unwrap();
-                    panic!("unknown: {}", e);
+                    panic!("unknown: {e}");
                 }
             }
         }
@@ -179,7 +177,7 @@ impl State {
     /// Prints summary statistics of how many modules have been instantiated so
     /// far and how many of them have oom'd or trap'd.
     fn print(&self, total: usize) {
-        print!("total: {:8}", total);
+        print!("total: {total:8}");
         let stat = |name: &str, stat: &AtomicUsize| {
             let stat = stat.load(SeqCst);
             if stat > 0 {

crates/wasm-compose/src/encoding.rs

@@ -364,7 +364,7 @@ impl<'a> TypeEncoder<'a> {
                 EntityType::Function(idx)
             }
             wasmparser::types::EntityType::Table(ty) => EntityType::Table(ty.try_into().unwrap()),
-            wasmparser::types::EntityType::Memory(ty) => EntityType::Memory(ty.try_into().unwrap()),
+            wasmparser::types::EntityType::Memory(ty) => EntityType::Memory(ty.into()),
             wasmparser::types::EntityType::Global(ty) => EntityType::Global(ty.try_into().unwrap()),
             wasmparser::types::EntityType::Tag(id) => {
                 let ty = &self.0.types[id];

crates/wasm-compose/tests/compose.rs

@@ -80,30 +80,21 @@ fn component_composing() -> Result<()> {
             }
         } else {
             let bytes =
-                r.with_context(|| format!("failed to encode for test case `{}`", test_case))?;
+                r.with_context(|| format!("failed to encode for test case `{test_case}`"))?;
 
             Validator::new_with_features(WasmFeatures::default() | WasmFeatures::COMPONENT_MODEL)
                 .validate_all(&bytes)
                 .with_context(|| {
-                    format!(
-                        "failed to validate component bytes for test case `{}`",
-                        test_case
-                    )
+                    format!("failed to validate component bytes for test case `{test_case}`")
                 })?;
 
             wit_component::decode(&bytes).with_context(|| {
-                format!(
-                    "failed to decode WIT from component bytes for test case `{}`",
-                    test_case
-                )
+                format!("failed to decode WIT from component bytes for test case `{test_case}`")
             })?;
 
             (
                 wasmprinter::print_bytes(&bytes).with_context(|| {
-                    format!(
-                        "failed to print component bytes for test case `{}`",
-                        test_case
-                    )
+                    format!("failed to print component bytes for test case `{test_case}`")
                 })?,
                 &output_path,
             )

crates/wasm-metadata/src/dependencies.rs

@@ -74,7 +74,7 @@ impl Display for Dependencies {
         // encoded as utf8, even if we internally store it as [u8].
         // let data = String::from_utf8(self.0.data.to_vec()).unwrap();
         let data = serde_json::to_string(&self.version_info).unwrap();
-        write!(f, "{}", data)
+        write!(f, "{data}")
     }
 }
 

crates/wasm-mutate-stats/src/bin/wasm-mutate-stats.rs

@@ -38,8 +38,7 @@ fn parse_optimization_types(s: &str) -> Result<OptLevel, ParsingOptLevelError> {
         "O2" => Ok(OptLevel::Speed),
         "Os" => Ok(OptLevel::SpeedAndSize),
         _ => Err(ParsingOptLevelError::Parsing(format!(
-            "Invalid optimization type {}",
-            s
+            "Invalid optimization type {s}"
         ))),
     }
 }
@@ -207,7 +206,7 @@ impl State {
                         newfolder.display()
                     )
                 })?;
-                println!("Artifacts saved at {:?}", newfolder);
+                println!("Artifacts saved at {newfolder:?}");
                 Ok(newfolder)
             })
             .collect::<anyhow::Result<Vec<_>>>()?;
@@ -260,7 +259,7 @@ impl State {
                 format!("File name could not be retrieved for {}", name.display())
             })?;
 
-            println!("Input wasm \"{:?}\"", filename);
+            println!("Input wasm \"{filename:?}\"");
             let artifacts_folder = self
                 .get_parent_folders(name.clone())?
                 .join("artifacts")
@@ -358,7 +357,7 @@ impl State {
     ) -> anyhow::Result<()> {
         let mut hashes = HashMap::new();
         //let low_hashes = HashMap::new();
-        let objfolder = artifact_folder.join("obj").join(format!("{:?}", optlevel));
+        let objfolder = artifact_folder.join("obj").join(format!("{optlevel:?}"));
         let entries = std::fs::read_dir(&objfolder)
             .with_context(|| format!("failed to read dir {}", objfolder.display()))?;
 
@@ -393,7 +392,7 @@ impl State {
 
     fn compile_and_save(&self, worklist: &[PathBuf], artifact_folder: &Path) -> anyhow::Result<()> {
         for (_, config) in &self.engines {
-            let newfolder = artifact_folder.join("obj").join(format!("{:?}", config));
+            let newfolder = artifact_folder.join("obj").join(format!("{config:?}"));
             std::fs::create_dir_all(&newfolder).with_context(|| {
                 format!(
                     "Artifacts folder {} could not be created",
@@ -423,8 +422,8 @@ impl State {
 
                 let filename = artifact_folder
                     .join("obj")
-                    .join(format!("{:?}", optlevel))
-                    .join(format!("{}.obj", entryidx));
+                    .join(format!("{optlevel:?}"))
+                    .join(format!("{entryidx}.obj"));
                 std::fs::write(&filename, &obj)
                     .context("Aot file could be written to filesystem")?;
             }
@@ -456,15 +455,15 @@ impl State {
             while !finish_writing_wrap_clone.load(Relaxed) {
                 // pop from worklist
                 if let Some(wasm) = to_write_clone.lock().unwrap().pop() {
-                    let filename = artifact_folder_cp.join(format!("mutated.{}.wasm", counter));
+                    let filename = artifact_folder_cp.join(format!("mutated.{counter}.wasm"));
                     std::fs::write(filename, &wasm).context("Failed to write mutated wasm")?;
                     counter += 1;
                 }
             }
             eprintln!("Writing down pending mutated binaries!");
             // Then write pending wasms
             while let Some(wasm) = to_write_clone.lock().unwrap().pop() {
-                let filename = artifact_folder_cp.join(format!("mutated.{}.wasm", counter));
+                let filename = artifact_folder_cp.join(format!("mutated.{counter}.wasm"));
 
                 std::fs::write(filename, &wasm).context("Failed to write mutated wasm")?;
                 counter += 1;
@@ -493,12 +492,12 @@ impl State {
             let data_clone = wasm.clone();
             panic::set_hook(Box::new(move |panic_info| {
                 // invoke the default handler and exit the process
-                println!("Internal unhandled panic:\n{:?}!", panic_info);
+                println!("Internal unhandled panic:\n{panic_info:?}!");
                 // stop generator
                 finish_writing_wrap_clone2.store(true, SeqCst);
                 // report current crash
                 if let Err(e) = self_clone.save_crash(&data_clone, None, seed, &artifact_clone) {
-                    eprintln!("Failed to save crash: {}", e);
+                    eprintln!("Failed to save crash: {e}");
                 }
                 process::exit(1);
             }));
@@ -578,14 +577,14 @@ impl State {
             format!("Crash folder could not be created {}", newfolder.display())
         })?;
 
-        let newfile = newfolder.join(format!("{}.original.wasm", seed));
+        let newfile = newfolder.join(format!("{seed}.original.wasm"));
 
         std::fs::write(&newfile, wasm)?;
 
         // Saving the mutation if one
 
         if let Some(mutated) = mutated {
-            let newfile = newfolder.join(format!("{}.mutated.wasm", seed));
+            let newfile = newfolder.join(format!("{seed}.mutated.wasm"));
             std::fs::write(newfile, mutated)?;
         }
 

crates/wasm-mutate/src/info.rs

@@ -68,7 +68,7 @@ impl<'a> ModuleInfo<'a> {
         loop {
             let (payload, consumed) = match parser.parse(wasm, true)? {
                 Chunk::NeedMoreData(hint) => {
-                    panic!("Invalid Wasm module {:?}", hint);
+                    panic!("Invalid Wasm module {hint:?}");
                 }
                 Chunk::Parsed { consumed, payload } => (payload, consumed),
             };

crates/wasm-mutate/src/lib.rs

@@ -334,5 +334,5 @@ pub(crate) fn validate(bytes: &[u8]) {
         drop(std::fs::write("test.wat", &text));
     }
 
-    panic!("wasm failed to validate: {} (written to test.wasm)", err);
+    panic!("wasm failed to validate: {err} (written to test.wasm)");
 }

crates/wasm-mutate/src/mutators.rs

@@ -149,7 +149,7 @@ impl WasmMutate<'_> {
                 Ok(Some(mutation)) => mutation.unwrap(),
                 Ok(None) => continue,
                 Err(e) if matches!(e.kind(), ErrorKind::NoMutationsApplicable) => continue,
-                Err(e) => panic!("mutation error: {}", e),
+                Err(e) => panic!("mutation error: {e}"),
             };
 
             let mutation_bytes = mutation.finish();
@@ -169,16 +169,12 @@ impl WasmMutate<'_> {
         match last_mutation {
             Some(mutation) => {
                 panic!(
-                    "after {} attempts the last mutation:\n{:?}\n\n\
-                     did not match the expected mutation\n{:?}",
-                    attempts, mutation, expected_text
+                    "after {attempts} attempts the last mutation:\n{mutation:?}\n\n\
+                     did not match the expected mutation\n{expected_text:?}"
                 );
             }
             None => {
-                panic!(
-                    "never found any applicable mutations after {} attempts",
-                    attempts
-                );
+                panic!("never found any applicable mutations after {attempts} attempts");
             }
         }
     }