chore(clippy): Place identifiers in format string (#663)

flub · web-flow · commit b7a4dd2b01db · 2023-01-02T12:35:30.000+01:00
Newer clippy wants the identifiers in the format string when
possible.  Boring change but why not.
diff --git a/iroh-api/benches/add.rs b/iroh-api/benches/add.rs
@@ -24,7 +24,7 @@ fn add_benchmark(c: &mut Criterion) {
     {
         let value = vec![8u8; *file_size];
         let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join(format!("{}.raw", file_size));
+        let path = dir.path().join(format!("{file_size}.raw"));
         std::fs::write(&path, value).unwrap();
 
         group.throughput(criterion::Throughput::Bytes(*file_size as u64));
diff --git a/iroh-bitswap/src/peer_task_queue.rs b/iroh-bitswap/src/peer_task_queue.rs
@@ -289,7 +289,7 @@ mod tests {
         // add blocks for all letters
         for letter in shuffled_alphabet {
             let i = alphabet.iter().position(|c| *c == letter).unwrap();
-            println!("{} - {}", letter, i);
+            println!("{letter} - {i}");
             ptq.push_task(
                 partner,
                 Task {
@@ -633,7 +633,7 @@ mod tests {
         let mut targets = Vec::new();
         for i in 0..n {
             let (peer, tasks, _) = ptq.pop_tasks(1).await.unwrap();
-            assert_eq!(tasks.len(), 1, "task {} did not match: {:?}", i, tasks);
+            assert_eq!(tasks.len(), 1, "task {i} did not match: {tasks:?}");
             targets.push(peer);
         }
         assert_eq_unordered(expected, targets);
diff --git a/iroh-one/src/main.rs b/iroh-one/src/main.rs
@@ -62,7 +62,7 @@ async fn main() -> Result<()> {
     };
 
     config.metrics = metrics::metrics_config_with_compile_time_info(config.metrics);
-    println!("{:#?}", config);
+    println!("{config:#?}");
 
     let metrics_config = config.metrics.clone();
 
diff --git a/iroh-p2p/src/keys.rs b/iroh-p2p/src/keys.rs
@@ -299,7 +299,7 @@ fn path_is_private_key<P: AsRef<Path>>(path: P) -> bool {
 fn print_algorithm(alg: ssh_key::Algorithm) -> &'static str {
     match alg {
         ssh_key::Algorithm::Ed25519 => "ed25519",
-        _ => panic!("unusupported algorithm {}", alg),
+        _ => panic!("unusupported algorithm {alg}"),
     }
 }
 
diff --git a/iroh-p2p/src/node.rs b/iroh-p2p/src/node.rs
@@ -155,7 +155,7 @@ impl<KeyStorage: Storage> Node<KeyStorage> {
 
         for addr in &libp2p_config.listening_multiaddrs {
             Swarm::listen_on(&mut swarm, addr.clone())?;
-            println!("{}", addr);
+            println!("{addr}");
         }
 
         Ok(Node {
@@ -1310,12 +1310,12 @@ mod tests {
                 assert!(!new_providers.is_empty());
 
                 for p in &new_providers {
-                    println!("{}", p);
+                    println!("{p}");
                     providers.push(*p);
                 }
             }
 
-            println!("{:?}", providers);
+            println!("{providers:?}");
             assert!(!providers.is_empty());
             assert!(
                 providers.len() >= DEFAULT_PROVIDER_LIMIT,
diff --git a/iroh-resolver/src/resolver.rs b/iroh-resolver/src/resolver.rs
@@ -1178,7 +1178,7 @@ mod tests {
         ];
 
         for test in roundtrip_tests {
-            println!("{}", test);
+            println!("{test}");
             let p: Path = test.parse().unwrap();
             assert_eq!(p.to_string(), test);
         }
@@ -1188,7 +1188,7 @@ mod tests {
             "/ipfs/bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy",
         )];
         for (test_in, test_out) in valid_tests {
-            println!("{}", test_in);
+            println!("{test_in}");
             let p: Path = test_in.parse().unwrap();
             assert_eq!(p.to_string(), test_out);
         }
@@ -1200,7 +1200,7 @@ mod tests {
             "/ipfs/ipfs.io",
         ];
         for test in invalid_tests {
-            println!("{}", test);
+            println!("{test}");
             assert!(test.parse::<Path>().is_err());
         }
     }
@@ -1452,7 +1452,7 @@ mod tests {
                     "hello\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_hello_txt);
+                panic!("invalid result: {ipld_hello_txt:?}");
             }
         }
 
@@ -1488,7 +1488,7 @@ mod tests {
                     "hello\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_hello_txt);
+                panic!("invalid result: {ipld_hello_txt:?}");
             }
         }
 
@@ -1551,7 +1551,7 @@ mod tests {
                     "world\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
     }
@@ -1609,7 +1609,7 @@ mod tests {
             let cr = seek_and_clip(ctx.clone(), &node, resolver.clone(), 1..3).await;
             assert_eq!(read_to_string(cr).await, "el");
         } else {
-            panic!("invalid result: {:?}", ipld_hello_txt);
+            panic!("invalid result: {ipld_hello_txt:?}");
         }
     }
 
@@ -1676,7 +1676,7 @@ mod tests {
                 assert!(content.starts_with("2.0</a>"));
                 assert!(content.ends_with("the Apac"));
             } else {
-                panic!("invalid result: {:?}", ipld_readme);
+                panic!("invalid result: {ipld_readme:?}");
             }
         }
     }
@@ -1845,7 +1845,7 @@ mod tests {
                     "hello\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_hello_txt);
+                panic!("invalid result: {ipld_hello_txt:?}");
             }
         }
 
@@ -1888,7 +1888,7 @@ mod tests {
                     "world\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
     }
@@ -1952,12 +1952,12 @@ mod tests {
                     .unwrap(),
                 )
                 .await;
-                print!("{}", content);
+                print!("{content}");
                 assert_eq!(content.len(), 426);
                 assert!(content.starts_with("# iroh"));
                 assert!(content.ends_with("</sub>\n\n"));
             } else {
-                panic!("invalid result: {:?}", ipld_readme);
+                panic!("invalid result: {ipld_readme:?}");
             }
         }
     }
@@ -2123,7 +2123,7 @@ mod tests {
                     "hello\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_hello_txt);
+                panic!("invalid result: {ipld_hello_txt:?}");
             }
         }
 
@@ -2180,7 +2180,7 @@ mod tests {
                     "world\n"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
 
@@ -2218,7 +2218,7 @@ mod tests {
                     "./bar.txt"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
 
@@ -2256,7 +2256,7 @@ mod tests {
                     "../../hello.txt"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
 
@@ -2294,7 +2294,7 @@ mod tests {
                     "../hello.txt"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
 
             let path = format!("/ipfs/{my_symlink_cid_str}");
@@ -2322,7 +2322,7 @@ mod tests {
                     "../hello.txt"
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_bar_txt);
+                panic!("invalid result: {ipld_bar_txt:?}");
             }
         }
     }
@@ -2388,7 +2388,7 @@ mod tests {
                     "world\n",
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_txt);
+                panic!("invalid result: {ipld_txt:?}");
             }
         }
         // read the directory listing
@@ -2429,7 +2429,7 @@ mod tests {
 
         for i in 1..=10000 {
             tokio::task::yield_now().await; // yield so sessions can be closed
-            let path = format!("/ipfs/{root_cid_str}/{}.txt", i);
+            let path = format!("/ipfs/{root_cid_str}/{i}.txt");
             let ipld_txt = resolver.resolve(path.parse().unwrap()).await.unwrap();
 
             assert!(ipld_txt
@@ -2456,10 +2456,10 @@ mod tests {
                         .unwrap()
                     )
                     .await,
-                    format!("{}\n", i),
+                    format!("{i}\n"),
                 );
             } else {
-                panic!("invalid result: {:?}", ipld_txt);
+                panic!("invalid result: {ipld_txt:?}");
             }
         }
     }
diff --git a/iroh-resolver/tests/roundtrip.rs b/iroh-resolver/tests/roundtrip.rs
@@ -167,7 +167,7 @@ async fn symlink_roundtrip_test() -> Result<()> {
     let mut reader = out.pretty(resolver, OutMetrics::default(), None)?;
     let mut t = String::new();
     reader.read_to_string(&mut t).await?;
-    println!("{}", t);
+    println!("{t}");
     assert_eq!(target, t);
     Ok(())
 }
@@ -248,7 +248,7 @@ fn test_hamt_roundtrip_3() {
 async fn test_hamt_roundtrip_large() {
     let mut dir = TestDir::new();
     for i in 0..10000 {
-        dir.insert(format!("file_{}", i), TestDirEntry::File(Bytes::new()));
+        dir.insert(format!("file_{i}"), TestDirEntry::File(Bytes::new()));
     }
     assert!(dir_roundtrip_test(dir, true).await.unwrap());
 }
diff --git a/iroh-resolver/tests/unixfs.rs b/iroh-resolver/tests/unixfs.rs
@@ -59,7 +59,7 @@ async fn test_dagger_testdata() -> Result<()> {
 
     for source in sources {
         for param in &params {
-            println!("== {:?} ==", source);
+            println!("== {source:?} ==");
             println!("Degree: {}", param.degree);
             println!("Chunker: {}", param.chunker);
 
@@ -81,7 +81,7 @@ async fn test_dagger_testdata() -> Result<()> {
             let out = resolver.resolve(Path::from_cid(root)).await?;
             let t = read_to_vec(out.pretty(resolver, OutMetrics::default(), None)?).await?;
 
-            println!("Root: {}", root);
+            println!("Root: {root}");
             println!("Len: {}", data.len());
             println!("Elapsed: {}s", start.elapsed().as_secs_f32());
 
diff --git a/iroh-share/src/main.rs b/iroh-share/src/main.rs
@@ -75,7 +75,7 @@ async fn main() -> Result<()> {
             let ticket = sender_transfer.ticket();
             let ticket_bytes = ticket.as_bytes();
             let ticket_str = multibase::encode(multibase::Base::Base64, &ticket_bytes);
-            println!("Ticket:\n{}\n", ticket_str);
+            println!("Ticket:\n{ticket_str}\n");
             sender_transfer.done().await?;
         }
         Commands::Receive { ticket, out } => {
@@ -102,10 +102,10 @@ async fn main() -> Result<()> {
                 while let Some(ev) = progress.next().await {
                     match ev {
                         Ok(ProgressEvent::Piece { index, total }) => {
-                            println!("transferred: {}/{}", index, total);
+                            println!("transferred: {index}/{total}");
                         }
                         Err(e) => {
-                            eprintln!("transfer failed: {}", e);
+                            eprintln!("transfer failed: {e}");
                         }
                     }
                 }
diff --git a/iroh-share/src/sender.rs b/iroh-share/src/sender.rs
@@ -57,7 +57,7 @@ impl Sender {
             gossip_task,
         } = self;
 
-        let t = Sha256Topic::new(format!("iroh-share-{}", id));
+        let t = Sha256Topic::new(format!("iroh-share-{id}"));
         let root_dir = dir_builder.build().await?;
 
         let (done_sender, done_receiver) = oneshot();
diff --git a/iroh-store/benches/rpc.rs b/iroh-store/benches/rpc.rs
@@ -48,7 +48,7 @@ pub fn put_benchmark(c: &mut Criterion) {
             group.bench_with_input(
                 BenchmarkId::new(
                     "(transport, value_size)",
-                    format!("({:?}, {})", transport, value_size),
+                    format!("({transport:?}, {value_size})"),
                 ),
                 &(key, value),
                 |b, (key, value)| {
@@ -101,7 +101,7 @@ pub fn get_benchmark(c: &mut Criterion) {
             group.bench_with_input(
                 BenchmarkId::new(
                     "(transport, value_size)",
-                    format!("({:?}, {})", transport, value_size),
+                    format!("({transport:?}, {value_size})"),
                 ),
                 &(),
                 |b, _| {
diff --git a/iroh-unixfs/src/balanced_tree.rs b/iroh-unixfs/src/balanced_tree.rs
@@ -331,7 +331,7 @@ mod tests {
 
     async fn build_expect(num_chunks: usize, degree: usize) -> Vec<Block> {
         let tree = build_expect_tree(num_chunks, degree).await;
-        println!("{:?}", tree);
+        println!("{tree:?}");
         build_expect_vec_from_tree(tree, num_chunks, degree).await
     }
 
@@ -414,7 +414,7 @@ mod tests {
             let node = node.expect("unexpected error in balanced tree stream");
             let (got_cid, got_bytes, _) = node.into_parts();
             let len = got_bytes.len() as u64;
-            println!("node index {}", i);
+            println!("node index {i}");
             assert_eq!(expect_cid, got_cid);
             assert_eq!(expect_bytes, got_bytes);
             i += 1;
diff --git a/iroh/src/fixture.rs b/iroh/src/fixture.rs
@@ -275,6 +275,6 @@ pub fn get_fixture_api() -> Api {
     let fixture_name = env::var("IROH_CTL_FIXTURE").expect("IROH_CTL_FIXTURE must be set");
     let fixture = registry
         .get(&fixture_name)
-        .unwrap_or_else(|| panic!("unknown fixture: {}", fixture_name));
+        .unwrap_or_else(|| panic!("unknown fixture: {fixture_name}"));
     fixture()
 }
diff --git a/iroh/src/main.rs b/iroh/src/main.rs
@@ -17,7 +17,7 @@ async fn main() -> Result<()> {
     match r {
         Ok(_) => Ok(()),
         Err(e) => {
-            eprintln!("Error: {:?}", e);
+            eprintln!("Error: {e:?}");
             std::process::exit(1);
         }
     }
@@ -42,7 +42,7 @@ fn transform_error(r: Result<()>) -> Result<()> {
                 return Err(anyhow!(
                     "Connection refused. This command requires a running {} service.\n{}",
                     service,
-                    format!("hint: try 'iroh start {}'", service).yellow(),
+                    format!("hint: try 'iroh start {service}'").yellow(),
                 ));
             }
             Err(e)
diff --git a/iroh/src/p2p.rs b/iroh/src/p2p.rs
diff --git a/iroh/src/run.rs b/iroh/src/run.rs
diff --git a/iroh/src/services.rs b/iroh/src/services.rs
diff --git a/xtask/src/main.rs b/xtask/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ fn add_benchmark(c: &mut Criterion) {`
`24`	`24`	`{`
`25`	`25`	`let value = vec![8u8; *file_size];`
`26`	`26`	`let dir = tempfile::tempdir().unwrap();`
`27`		`- let path = dir.path().join(format!("{}.raw", file_size));`
	`27`	`+ let path = dir.path().join(format!("{file_size}.raw"));`
`28`	`28`	`std::fs::write(&path, value).unwrap();`
`29`	`29`
`30`	`30`	`group.throughput(criterion::Throughput::Bytes(*file_size as u64));`
Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ fn path_is_private_key<P: AsRef<Path>>(path: P) -> bool {`
`299`	`299`	`fn print_algorithm(alg: ssh_key::Algorithm) -> &'static str {`
`300`	`300`	`match alg {`
`301`	`301`	`ssh_key::Algorithm::Ed25519 => "ed25519",`
`302`		`- _ => panic!("unusupported algorithm {}", alg),`
	`302`	`+ _ => panic!("unusupported algorithm {alg}"),`
`303`	`303`	`}`
`304`	`304`	`}`
`305`	`305`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ impl<KeyStorage: Storage> Node<KeyStorage> {`
`155`	`155`
`156`	`156`	`for addr in &libp2p_config.listening_multiaddrs {`
`157`	`157`	`Swarm::listen_on(&mut swarm, addr.clone())?;`
`158`		`- println!("{}", addr);`
	`158`	`+ println!("{addr}");`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`Ok(Node {`
`@@ -1310,12 +1310,12 @@ mod tests {`
`1310`	`1310`	`assert!(!new_providers.is_empty());`
`1311`	`1311`
`1312`	`1312`	`for p in &new_providers {`
`1313`		`- println!("{}", p);`
	`1313`	`+ println!("{p}");`
`1314`	`1314`	`providers.push(*p);`
`1315`	`1315`	`}`
`1316`	`1316`	`}`
`1317`	`1317`
`1318`		`- println!("{:?}", providers);`
	`1318`	`+ println!("{providers:?}");`
`1319`	`1319`	`assert!(!providers.is_empty());`
`1320`	`1320`	`assert!(`
`1321`	`1321`	`providers.len() >= DEFAULT_PROVIDER_LIMIT,`
Original file line number	Diff line number	Diff line change
`@@ -1178,7 +1178,7 @@ mod tests {`
`1178`	`1178`	`];`
`1179`	`1179`
`1180`	`1180`	`for test in roundtrip_tests {`
`1181`		`- println!("{}", test);`
	`1181`	`+ println!("{test}");`
`1182`	`1182`	`let p: Path = test.parse().unwrap();`
`1183`	`1183`	`assert_eq!(p.to_string(), test);`
`1184`	`1184`	`}`
`@@ -1188,7 +1188,7 @@ mod tests {`
`1188`	`1188`	`"/ipfs/bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy",`
`1189`	`1189`	`)];`
`1190`	`1190`	`for (test_in, test_out) in valid_tests {`
`1191`		`- println!("{}", test_in);`
	`1191`	`+ println!("{test_in}");`
`1192`	`1192`	`let p: Path = test_in.parse().unwrap();`
`1193`	`1193`	`assert_eq!(p.to_string(), test_out);`
`1194`	`1194`	`}`
`@@ -1200,7 +1200,7 @@ mod tests {`
`1200`	`1200`	`"/ipfs/ipfs.io",`
`1201`	`1201`	`];`
`1202`	`1202`	`for test in invalid_tests {`
`1203`		`- println!("{}", test);`
	`1203`	`+ println!("{test}");`
`1204`	`1204`	`assert!(test.parse::<Path>().is_err());`
`1205`	`1205`	`}`
`1206`	`1206`	`}`
`@@ -1452,7 +1452,7 @@ mod tests {`
`1452`	`1452`	`"hello\n"`
`1453`	`1453`	`);`
`1454`	`1454`	`} else {`
`1455`		`- panic!("invalid result: {:?}", ipld_hello_txt);`
	`1455`	`+ panic!("invalid result: {ipld_hello_txt:?}");`
`1456`	`1456`	`}`
`1457`	`1457`	`}`
`1458`	`1458`
`@@ -1488,7 +1488,7 @@ mod tests {`
`1488`	`1488`	`"hello\n"`
`1489`	`1489`	`);`
`1490`	`1490`	`} else {`
`1491`		`- panic!("invalid result: {:?}", ipld_hello_txt);`
	`1491`	`+ panic!("invalid result: {ipld_hello_txt:?}");`
`1492`	`1492`	`}`
`1493`	`1493`	`}`
`1494`	`1494`
`@@ -1551,7 +1551,7 @@ mod tests {`
`1551`	`1551`	`"world\n"`
`1552`	`1552`	`);`
`1553`	`1553`	`} else {`
`1554`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`1554`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`1555`	`1555`	`}`
`1556`	`1556`	`}`
`1557`	`1557`	`}`
`@@ -1609,7 +1609,7 @@ mod tests {`
`1609`	`1609`	`let cr = seek_and_clip(ctx.clone(), &node, resolver.clone(), 1..3).await;`
`1610`	`1610`	`assert_eq!(read_to_string(cr).await, "el");`
`1611`	`1611`	`} else {`
`1612`		`- panic!("invalid result: {:?}", ipld_hello_txt);`
	`1612`	`+ panic!("invalid result: {ipld_hello_txt:?}");`
`1613`	`1613`	`}`
`1614`	`1614`	`}`
`1615`	`1615`
`@@ -1676,7 +1676,7 @@ mod tests {`
`1676`	`1676`	`assert!(content.starts_with("2.0</a>"));`
`1677`	`1677`	`assert!(content.ends_with("the Apac"));`
`1678`	`1678`	`} else {`
`1679`		`- panic!("invalid result: {:?}", ipld_readme);`
	`1679`	`+ panic!("invalid result: {ipld_readme:?}");`
`1680`	`1680`	`}`
`1681`	`1681`	`}`
`1682`	`1682`	`}`
`@@ -1845,7 +1845,7 @@ mod tests {`
`1845`	`1845`	`"hello\n"`
`1846`	`1846`	`);`
`1847`	`1847`	`} else {`
`1848`		`- panic!("invalid result: {:?}", ipld_hello_txt);`
	`1848`	`+ panic!("invalid result: {ipld_hello_txt:?}");`
`1849`	`1849`	`}`
`1850`	`1850`	`}`
`1851`	`1851`
`@@ -1888,7 +1888,7 @@ mod tests {`
`1888`	`1888`	`"world\n"`
`1889`	`1889`	`);`
`1890`	`1890`	`} else {`
`1891`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`1891`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`1892`	`1892`	`}`
`1893`	`1893`	`}`
`1894`	`1894`	`}`
`@@ -1952,12 +1952,12 @@ mod tests {`
`1952`	`1952`	`.unwrap(),`
`1953`	`1953`	`)`
`1954`	`1954`	`.await;`
`1955`		`- print!("{}", content);`
	`1955`	`+ print!("{content}");`
`1956`	`1956`	`assert_eq!(content.len(), 426);`
`1957`	`1957`	`assert!(content.starts_with("# iroh"));`
`1958`	`1958`	`assert!(content.ends_with("</sub>\n\n"));`
`1959`	`1959`	`} else {`
`1960`		`- panic!("invalid result: {:?}", ipld_readme);`
	`1960`	`+ panic!("invalid result: {ipld_readme:?}");`
`1961`	`1961`	`}`
`1962`	`1962`	`}`
`1963`	`1963`	`}`
`@@ -2123,7 +2123,7 @@ mod tests {`
`2123`	`2123`	`"hello\n"`
`2124`	`2124`	`);`
`2125`	`2125`	`} else {`
`2126`		`- panic!("invalid result: {:?}", ipld_hello_txt);`
	`2126`	`+ panic!("invalid result: {ipld_hello_txt:?}");`
`2127`	`2127`	`}`
`2128`	`2128`	`}`
`2129`	`2129`
`@@ -2180,7 +2180,7 @@ mod tests {`
`2180`	`2180`	`"world\n"`
`2181`	`2181`	`);`
`2182`	`2182`	`} else {`
`2183`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`2183`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`2184`	`2184`	`}`
`2185`	`2185`	`}`
`2186`	`2186`
`@@ -2218,7 +2218,7 @@ mod tests {`
`2218`	`2218`	`"./bar.txt"`
`2219`	`2219`	`);`
`2220`	`2220`	`} else {`
`2221`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`2221`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`2222`	`2222`	`}`
`2223`	`2223`	`}`
`2224`	`2224`
`@@ -2256,7 +2256,7 @@ mod tests {`
`2256`	`2256`	`"../../hello.txt"`
`2257`	`2257`	`);`
`2258`	`2258`	`} else {`
`2259`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`2259`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`2260`	`2260`	`}`
`2261`	`2261`	`}`
`2262`	`2262`
`@@ -2294,7 +2294,7 @@ mod tests {`
`2294`	`2294`	`"../hello.txt"`
`2295`	`2295`	`);`
`2296`	`2296`	`} else {`
`2297`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`2297`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`2298`	`2298`	`}`
`2299`	`2299`
`2300`	`2300`	`let path = format!("/ipfs/{my_symlink_cid_str}");`
`@@ -2322,7 +2322,7 @@ mod tests {`
`2322`	`2322`	`"../hello.txt"`
`2323`	`2323`	`);`
`2324`	`2324`	`} else {`
`2325`		`- panic!("invalid result: {:?}", ipld_bar_txt);`
	`2325`	`+ panic!("invalid result: {ipld_bar_txt:?}");`
`2326`	`2326`	`}`
`2327`	`2327`	`}`
`2328`	`2328`	`}`
`@@ -2388,7 +2388,7 @@ mod tests {`
`2388`	`2388`	`"world\n",`
`2389`	`2389`	`);`
`2390`	`2390`	`} else {`
`2391`		`- panic!("invalid result: {:?}", ipld_txt);`
	`2391`	`+ panic!("invalid result: {ipld_txt:?}");`
`2392`	`2392`	`}`
`2393`	`2393`	`}`
`2394`	`2394`	`// read the directory listing`
`@@ -2429,7 +2429,7 @@ mod tests {`
`2429`	`2429`
`2430`	`2430`	`for i in 1..=10000 {`
`2431`	`2431`	`tokio::task::yield_now().await; // yield so sessions can be closed`
`2432`		`- let path = format!("/ipfs/{root_cid_str}/{}.txt", i);`
	`2432`	`+ let path = format!("/ipfs/{root_cid_str}/{i}.txt");`
`2433`	`2433`	`let ipld_txt = resolver.resolve(path.parse().unwrap()).await.unwrap();`
`2434`	`2434`
`2435`	`2435`	`assert!(ipld_txt`
`@@ -2456,10 +2456,10 @@ mod tests {`
`2456`	`2456`	`.unwrap()`
`2457`	`2457`	`)`
`2458`	`2458`	`.await,`
`2459`		`- format!("{}\n", i),`
	`2459`	`+ format!("{i}\n"),`
`2460`	`2460`	`);`
`2461`	`2461`	`} else {`
`2462`		`- panic!("invalid result: {:?}", ipld_txt);`
	`2462`	`+ panic!("invalid result: {ipld_txt:?}");`
`2463`	`2463`	`}`
`2464`	`2464`	`}`
`2465`	`2465`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ async fn symlink_roundtrip_test() -> Result<()> {`
`167`	`167`	`let mut reader = out.pretty(resolver, OutMetrics::default(), None)?;`
`168`	`168`	`let mut t = String::new();`
`169`	`169`	`reader.read_to_string(&mut t).await?;`
`170`		`- println!("{}", t);`
	`170`	`+ println!("{t}");`
`171`	`171`	`assert_eq!(target, t);`
`172`	`172`	`Ok(())`
`173`	`173`	`}`
`@@ -248,7 +248,7 @@ fn test_hamt_roundtrip_3() {`
`248`	`248`	`async fn test_hamt_roundtrip_large() {`
`249`	`249`	`let mut dir = TestDir::new();`
`250`	`250`	`for i in 0..10000 {`
`251`		`- dir.insert(format!("file_{}", i), TestDirEntry::File(Bytes::new()));`
	`251`	`+ dir.insert(format!("file_{i}"), TestDirEntry::File(Bytes::new()));`
`252`	`252`	`}`
`253`	`253`	`assert!(dir_roundtrip_test(dir, true).await.unwrap());`
`254`	`254`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ async fn main() -> Result<()> {`
`75`	`75`	`let ticket = sender_transfer.ticket();`
`76`	`76`	`let ticket_bytes = ticket.as_bytes();`
`77`	`77`	`let ticket_str = multibase::encode(multibase::Base::Base64, &ticket_bytes);`
`78`		`- println!("Ticket:\n{}\n", ticket_str);`
	`78`	`+ println!("Ticket:\n{ticket_str}\n");`
`79`	`79`	`sender_transfer.done().await?;`
`80`	`80`	`}`
`81`	`81`	`Commands::Receive { ticket, out } => {`
`@@ -102,10 +102,10 @@ async fn main() -> Result<()> {`
`102`	`102`	`while let Some(ev) = progress.next().await {`
`103`	`103`	`match ev {`
`104`	`104`	`Ok(ProgressEvent::Piece { index, total }) => {`
`105`		`- println!("transferred: {}/{}", index, total);`
	`105`	`+ println!("transferred: {index}/{total}");`
`106`	`106`	`}`
`107`	`107`	`Err(e) => {`
`108`		`- eprintln!("transfer failed: {}", e);`
	`108`	`+ eprintln!("transfer failed: {e}");`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -275,6 +275,6 @@ pub fn get_fixture_api() -> Api {`
`275`	`275`	`let fixture_name = env::var("IROH_CTL_FIXTURE").expect("IROH_CTL_FIXTURE must be set");`
`276`	`276`	`let fixture = registry`
`277`	`277`	`.get(&fixture_name)`
`278`		`- .unwrap_or_else(\|\| panic!("unknown fixture: {}", fixture_name));`
	`278`	`+ .unwrap_or_else(\|\| panic!("unknown fixture: {fixture_name}"));`
`279`	`279`	`fixture()`
`280`	`280`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ async fn main() -> Result<()> {`
`17`	`17`	`match r {`
`18`	`18`	`Ok(_) => Ok(()),`
`19`	`19`	`Err(e) => {`
`20`		`- eprintln!("Error: {:?}", e);`
	`20`	`+ eprintln!("Error: {e:?}");`
`21`	`21`	`std::process::exit(1);`
`22`	`22`	`}`
`23`	`23`	`}`
`@@ -42,7 +42,7 @@ fn transform_error(r: Result<()>) -> Result<()> {`
`42`	`42`	`return Err(anyhow!(`
`43`	`43`	`"Connection refused. This command requires a running {} service.\n{}",`
`44`	`44`	`service,`
`45`		`- format!("hint: try 'iroh start {}'", service).yellow(),`
	`45`	`+ format!("hint: try 'iroh start {service}'").yellow(),`
`46`	`46`	`));`
`47`	`47`	`}`
`48`	`48`	`Err(e)`