style: simplify string formatting (bytecodealliance#9047)

* style: simplify string formatting

* fix: formatting in `benches/call.rs`

Author: hamirmahal

benches/call.rs

@@ -139,7 +139,7 @@ fn bench_host_to_wasm<Params, Results>(
 {
     // Benchmark the "typed" version, which should be faster than the versions
     // below.
-    c.bench_function(&format!("core - host-to-wasm - typed - {}", name), |b| {
+    c.bench_function(&format!("core - host-to-wasm - typed - {name}"), |b| {
         let typed = instance
             .get_typed_func::<Params, Results>(&mut *store, name)
             .unwrap();
@@ -155,7 +155,7 @@ fn bench_host_to_wasm<Params, Results>(
 
     // Benchmark the "untyped" version which should be the slowest of the three
     // here, but not unduly slow.
-    c.bench_function(&format!("core - host-to-wasm - untyped - {}", name), |b| {
+    c.bench_function(&format!("core - host-to-wasm - untyped - {name}"), |b| {
         let untyped = instance.get_func(&mut *store, name).unwrap();
         let params = typed_params.to_vals();
         let expected_results = typed_results.to_vals();
@@ -180,28 +180,25 @@ fn bench_host_to_wasm<Params, Results>(
 
     // Benchmark the "unchecked" version which should be between the above two,
     // but is unsafe.
-    c.bench_function(
-        &format!("core - host-to-wasm - unchecked - {}", name),
-        |b| {
-            let untyped = instance.get_func(&mut *store, name).unwrap();
-            let params = typed_params.to_vals();
-            let results = typed_results.to_vals();
-            let mut space = vec![ValRaw::i32(0); params.len().max(results.len())];
-            b.iter(|| unsafe {
-                for (i, param) in params.iter().enumerate() {
-                    space[i] = param.to_raw(&mut *store).unwrap();
-                }
-                untyped
-                    .call_unchecked(&mut *store, space.as_mut_ptr(), space.len())
-                    .unwrap();
-                for (i, expected) in results.iter().enumerate() {
-                    let ty = expected.ty(&store).unwrap();
-                    let actual = Val::from_raw(&mut *store, space[i], ty);
-                    assert_vals_eq(expected, &actual);
-                }
-            })
-        },
-    );
+    c.bench_function(&format!("core - host-to-wasm - unchecked - {name}"), |b| {
+        let untyped = instance.get_func(&mut *store, name).unwrap();
+        let params = typed_params.to_vals();
+        let results = typed_results.to_vals();
+        let mut space = vec![ValRaw::i32(0); params.len().max(results.len())];
+        b.iter(|| unsafe {
+            for (i, param) in params.iter().enumerate() {
+                space[i] = param.to_raw(&mut *store).unwrap();
+            }
+            untyped
+                .call_unchecked(&mut *store, space.as_mut_ptr(), space.len())
+                .unwrap();
+            for (i, expected) in results.iter().enumerate() {
+                let ty = expected.ty(&store).unwrap();
+                let actual = Val::from_raw(&mut *store, space[i], ty);
+                assert_vals_eq(expected, &actual);
+            }
+        })
+    });
 }
 
 /// Benchmarks the overhead of calling the host from WebAssembly itself
@@ -398,7 +395,7 @@ fn wasm_to_host(c: &mut Criterion) {
         desc: &str,
         is_async: IsAsync,
     ) {
-        group.bench_function(&format!("core - wasm-to-host - {} - nop", desc), |b| {
+        group.bench_function(&format!("core - wasm-to-host - {desc} - nop"), |b| {
             let run = instance
                 .get_typed_func::<u64, ()>(&mut *store, "run-nop")
                 .unwrap();
@@ -413,7 +410,7 @@ fn wasm_to_host(c: &mut Criterion) {
             })
         });
         group.bench_function(
-            &format!("core - wasm-to-host - {} - nop-params-and-results", desc),
+            &format!("core - wasm-to-host - {desc} - nop-params-and-results"),
             |b| {
                 let run = instance
                     .get_typed_func::<u64, ()>(&mut *store, "run-nop-params-and-results")
@@ -636,31 +633,28 @@ mod component {
             + Sync,
     {
         // Benchmark the "typed" version.
-        c.bench_function(
-            &format!("component - host-to-wasm - typed - {}", name),
-            |b| {
-                let typed = instance
-                    .get_typed_func::<Params, Results>(&mut *store, name)
-                    .unwrap();
-                b.iter(|| {
-                    let results = if is_async.use_async() {
-                        run_await(typed.call_async(&mut *store, typed_params)).unwrap()
-                    } else {
-                        typed.call(&mut *store, typed_params).unwrap()
-                    };
-                    assert_eq!(results, typed_results);
-                    if is_async.use_async() {
-                        run_await(typed.post_return_async(&mut *store)).unwrap()
-                    } else {
-                        typed.post_return(&mut *store).unwrap()
-                    }
-                })
-            },
-        );
+        c.bench_function(&format!("component - host-to-wasm - typed - {name}"), |b| {
+            let typed = instance
+                .get_typed_func::<Params, Results>(&mut *store, name)
+                .unwrap();
+            b.iter(|| {
+                let results = if is_async.use_async() {
+                    run_await(typed.call_async(&mut *store, typed_params)).unwrap()
+                } else {
+                    typed.call(&mut *store, typed_params).unwrap()
+                };
+                assert_eq!(results, typed_results);
+                if is_async.use_async() {
+                    run_await(typed.post_return_async(&mut *store)).unwrap()
+                } else {
+                    typed.post_return(&mut *store).unwrap()
+                }
+            })
+        });
 
         // Benchmark the "untyped" version.
         c.bench_function(
-            &format!("component - host-to-wasm - untyped - {}", name),
+            &format!("component - host-to-wasm - untyped - {name}"),
             |b| {
                 let untyped = instance.get_func(&mut *store, name).unwrap();
                 let params = typed_params.to_component_vals();
@@ -864,7 +858,7 @@ mod component {
             desc: &str,
             is_async: IsAsync,
         ) {
-            group.bench_function(&format!("component - wasm-to-host - {} - nop", desc), |b| {
+            group.bench_function(&format!("component - wasm-to-host - {desc} - nop"), |b| {
                 let run = instance
                     .get_typed_func::<(u64,), ()>(&mut *store, "run-nop")
                     .unwrap();
@@ -881,10 +875,7 @@ mod component {
                 })
             });
             group.bench_function(
-                &format!(
-                    "component - wasm-to-host - {} - nop-params-and-results",
-                    desc
-                ),
+                &format!("component - wasm-to-host - {desc} - nop-params-and-results"),
                 |b| {
                     let run = instance
                         .get_typed_func::<(u64,), ()>(&mut *store, "run-nop-params-and-results")

examples/component/main.rs

@@ -57,6 +57,6 @@ fn main() -> Result<()> {
     host::add_to_linker(&mut linker, |state: &mut MyState| &mut state.host)?;
     let convert = Convert::instantiate(&mut store, &component, &linker)?;
     let result = convert.call_convert_celsius_to_fahrenheit(&mut store, 23.4)?;
-    println!("Converted to: {:?}", result);
+    println!("Converted to: {result:?}");
     Ok(())
 }

examples/fuel.rs

@@ -21,12 +21,12 @@ fn main() -> Result<()> {
             Ok(v) => v,
             Err(e) => {
                 assert_eq!(e.downcast::<Trap>()?, Trap::OutOfFuel);
-                println!("Exhausted fuel computing fib({})", n);
+                println!("Exhausted fuel computing fib({n})");
                 break;
             }
         };
         let fuel_consumed = fuel_before - store.get_fuel().unwrap();
-        println!("fib({}) = {} [consumed {} fuel]", n, output, fuel_consumed);
+        println!("fib({n}) = {output} [consumed {fuel_consumed} fuel]");
         store.set_fuel(10_000)?;
     }
     Ok(())

examples/multi.rs

@@ -40,7 +40,7 @@ fn main() -> Result<()> {
     let (a, b) = g.call(&mut store, (1, 3))?;
 
     println!("Printing result...");
-    println!("> {} {}", a, b);
+    println!("> {a} {b}");
 
     assert_eq!(a, 4);
     assert_eq!(b, 2);
@@ -56,7 +56,7 @@ fn main() -> Result<()> {
     let results = round_trip_many.call(&mut store, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9))?;
 
     println!("Printing result...");
-    println!("> {:?}", results);
+    println!("> {results:?}");
     assert_eq!(results, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
 
     Ok(())

src/commands/run.rs

@@ -508,7 +508,7 @@ impl RunCommand {
             .call(&mut *store, &values, &mut results)
             .with_context(|| {
                 if let Some(name) = &self.invoke {
-                    format!("failed to invoke `{}`", name)
+                    format!("failed to invoke `{name}`")
                 } else {
                     format!("failed to invoke command default")
                 }
@@ -527,8 +527,8 @@ impl RunCommand {
 
         for result in results {
             match result {
-                Val::I32(i) => println!("{}", i),
-                Val::I64(i) => println!("{}", i),
+                Val::I32(i) => println!("{i}"),
+                Val::I64(i) => println!("{i}"),
                 Val::F32(f) => println!("{}", f32::from_bits(f)),
                 Val::F64(f) => println!("{}", f64::from_bits(f)),
                 Val::V128(i) => println!("{}", i.as_u128()),
@@ -558,10 +558,10 @@ impl RunCommand {
             .unwrap_or_else(|| "unknown");
 
         if let Err(coredump_err) = write_core_dump(store, &err, &source_name, coredump_path) {
-            eprintln!("warning: coredump failed to generate: {}", coredump_err);
+            eprintln!("warning: coredump failed to generate: {coredump_err}");
             err
         } else {
-            err.context(format!("core dumped at {}", coredump_path))
+            err.context(format!("core dumped at {coredump_path}"))
         }
     }
 
@@ -847,7 +847,7 @@ impl RunCommand {
 
         for (host, guest) in self.run.dirs.iter() {
             let dir = Dir::open_ambient_dir(host, ambient_authority())
-                .with_context(|| format!("failed to open directory '{}'", host))?;
+                .with_context(|| format!("failed to open directory '{host}'"))?;
             builder.preopened_dir(dir, guest)?;
         }
 
@@ -989,9 +989,9 @@ fn write_core_dump(
     let core_dump = core_dump.serialize(store, name);
 
     let mut core_dump_file =
-        File::create(path).context(format!("failed to create file at `{}`", path))?;
+        File::create(path).context(format!("failed to create file at `{path}`"))?;
     core_dump_file
         .write_all(&core_dump)
-        .with_context(|| format!("failed to write core dump file at `{}`", path))?;
+        .with_context(|| format!("failed to write core dump file at `{path}`"))?;
     Ok(())
 }

src/commands/settings.rs

@@ -156,7 +156,7 @@ impl SettingsCommand {
             println!("Settings inferred for the current host:");
 
             for name in inferred {
-                println!("  {}", name);
+                println!("  {name}");
             }
         }
 
@@ -169,7 +169,7 @@ impl SettingsCommand {
         }
 
         println!();
-        println!("{}", header);
+        println!("{header}");
 
         let width = settings.iter().map(|s| s.0.name.len()).max().unwrap_or(0);
 

src/common.rs

@@ -327,7 +327,7 @@ impl RunCommon {
 
         for address in &self.common.wasi.tcplisten {
             let stdlistener = std::net::TcpListener::bind(address)
-                .with_context(|| format!("failed to bind to address '{}'", address))?;
+                .with_context(|| format!("failed to bind to address '{address}'"))?;
 
             let _ = stdlistener.set_nonblocking(true)?;
 

tests/all/cli_tests.rs

@@ -221,8 +221,7 @@ fn timeout_in_start() -> Result<()> {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
         stderr.contains("wasm trap: interrupt"),
-        "bad stderr: {}",
-        stderr
+        "bad stderr: {stderr}"
     );
     Ok(())
 }
@@ -244,8 +243,7 @@ fn timeout_in_invoke() -> Result<()> {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
         stderr.contains("wasm trap: interrupt"),
-        "bad stderr: {}",
-        stderr
+        "bad stderr: {stderr}"
     );
     Ok(())
 }
@@ -1347,7 +1345,7 @@ mod test_programs {
         )?;
         println!("{}", String::from_utf8_lossy(&output.stderr));
         let stdout = String::from_utf8_lossy(&output.stdout);
-        println!("{}", stdout);
+        println!("{stdout}");
         assert!(stdout.starts_with("Called _start\n"));
         assert!(stdout.ends_with("Done\n"));
         assert!(output.status.success());

tests/all/component_model/bindgen/results.rs

@@ -251,7 +251,7 @@ mod enum_error {
 
     impl std::fmt::Display for MyTrap {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{:?}", self)
+            write!(f, "{self:?}")
         }
     }
     impl std::error::Error for MyTrap {}
@@ -877,7 +877,7 @@ mod multiple_interfaces_error {
 
         impl std::fmt::Display for MyTrap {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(f, "{:?}", self)
+                write!(f, "{self:?}")
             }
         }
         impl std::error::Error for MyTrap {}

tests/all/component_model/func.rs

@@ -1124,8 +1124,7 @@ fn some_traps() -> Result<()> {
         assert!(
             err.to_string()
                 .contains("realloc return: beyond end of memory"),
-            "{:?}",
-            err,
+            "{err:?}",
         );
     }
     let err = instance(&mut store)?