[base] Fix some new clippy warnings (following rustup update).

youngman-g · youngman-g · commit 7c97fd46b77b · 2025-07-04T21:43:33.000+01:00
diff --git a/base/src/charset.rs b/base/src/charset.rs
@@ -138,8 +138,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {
             ) => {
                 write!(
                     f,
-                    "cannot convert code {:#o} from Lincoln Writer character set to Unicode, because it has no printable representation",
-                    n
+                    "cannot convert code {n:#o} from Lincoln Writer character set to Unicode, because it has no printable representation",
                 )
             }
             LincolnToUnicodeStrictConversionFailure::CannotSubscript(
@@ -148,9 +147,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {
             ) => {
                 write!(
                     f,
-                    "cannot convert {:#o} from Lincoln Writer character set to Unicode, because Unicode has no subscript form of '{}'",
-                    u,
-                    ch
+                    "cannot convert {u:#o} from Lincoln Writer character set to Unicode, because Unicode has no subscript form of '{ch}'",
                 )
             }
             LincolnToUnicodeStrictConversionFailure::CannotSuperscript(
@@ -159,9 +156,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {
             ) => {
                 write!(
                     f,
-                    "cannot convert {:#o} from Lincoln Writer character set to Unicode, because Unicode has no superscript form of '{}'",
-                    u,
-                    ch
+                    "cannot convert {u:#o} from Lincoln Writer character set to Unicode, because Unicode has no superscript form of '{ch}'",
                 )
             }
         }
@@ -620,8 +615,7 @@ impl Display for UnicodeToLincolnConversionFailure {
             UnicodeToLincolnConversionFailure::NoMapping(ch) => {
                 write!(
                     f,
-                    "there is no mapping for '{}' from Unicode to Lincoln Writer character set",
-                    ch,
+                    "there is no mapping for '{ch}' from Unicode to Lincoln Writer character set",
                 )
             }
         }
diff --git a/base/src/charset/tests.rs b/base/src/charset/tests.rs
@@ -77,11 +77,11 @@ fn round_trip() {
                     assert_eq!(input, s);
                 }
                 Err(e) => {
-                    panic!("failed to convert back to unicode: {}", e);
+                    panic!("failed to convert back to unicode: {e}");
                 }
             },
             Err(e) => {
-                panic!("failed to convert [{}] to Lincoln: {}", input, e);
+                panic!("failed to convert [{input}] to Lincoln: {e}");
             }
         }
     }
diff --git a/base/src/instruction.rs b/base/src/instruction.rs
@@ -139,8 +139,8 @@ impl From<Instruction> for Unsigned36Bit {
 impl Debug for Instruction {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         let lhs = match SymbolicInstruction::try_from(self) {
-            Ok(sym) => format!("{}", sym),
-            Err(e) => format!("(invalid instruction: {})", e),
+            Ok(sym) => format!("{sym}"),
+            Err(e) => format!("(invalid instruction: {e})"),
         };
         write!(f, "{:<40} {}", lhs, self.0)
     }
@@ -510,7 +510,7 @@ impl Debug for DisassemblyFailure {
                 n
             }
         };
-        write!(f, "(0{:o})", opcode)
+        write!(f, "(0{opcode:o})")
     }
 }
 
diff --git a/base/src/instruction/format.rs b/base/src/instruction/format.rs
@@ -109,10 +109,10 @@ impl Octal for OperandAddress {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
             OperandAddress::Direct(addr) => {
-                write!(f, "{:o}", addr)
+                write!(f, "{addr:o}")
             }
             OperandAddress::Deferred(addr) => {
-                write!(f, "[{:o}]", addr)
+                write!(f, "[{addr:o}]")
             }
         }
     }
@@ -130,20 +130,20 @@ impl Display for DisassemblyFailure {
                 n
             }
         };
-        write!(f, " {:03o}", opcode)
+        write!(f, " {opcode:03o}")
     }
 }
 
 fn octal_superscript_u8(n: u8) -> Result<String, NoSuperscriptKnown> {
-    format!("{:o}", n).chars().map(superscript_char).collect()
+    format!("{n:o}").chars().map(superscript_char).collect()
 }
 
 fn subscript(s: &str) -> Result<String, NoSubscriptKnown> {
     s.chars().map(subscript_char).collect()
 }
 
 fn octal_subscript_number(n: u8) -> String {
-    subscript(&format!("{:o}", n)).unwrap()
+    subscript(&format!("{n:o}")).unwrap()
 }
 
 fn write_opcode(op: Opcode, cfg: Unsigned5Bit, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
@@ -204,7 +204,7 @@ fn write_opcode(op: Opcode, cfg: Unsigned5Bit, f: &mut Formatter<'_>) -> Result<
             0o14 => "SUR",
             _ => "SKM",
         }),
-        _ => write!(f, "{}", op),
+        _ => write!(f, "{op}"),
     }
 }
 
diff --git a/base/src/onescomplement/signed/tests18.rs b/base/src/onescomplement/signed/tests18.rs
@@ -86,10 +86,7 @@ fn test_i8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -99,8 +96,8 @@ fn test_i8_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -114,10 +111,7 @@ fn test_i16_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -127,8 +121,8 @@ fn test_i16_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -142,10 +136,7 @@ fn test_u8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -155,8 +146,8 @@ fn test_u8_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -170,10 +161,7 @@ fn test_u16_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -183,8 +171,8 @@ fn test_u16_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -322,8 +310,8 @@ fn test_from_signed18bit_to_i16() {
 
 #[test]
 fn test_from_u16_to_signed18bit() {
-    assert_eq!(Signed18Bit::try_from(0_u16), Ok(Signed18Bit::ZERO));
-    assert_eq!(Signed18Bit::try_from(1_u16), Ok(Signed18Bit::ONE));
+    assert_eq!(Signed18Bit::from(0_u16), Signed18Bit::ZERO);
+    assert_eq!(Signed18Bit::from(1_u16), Signed18Bit::ONE);
     assert_eq!(Signed18Bit::from(0o377_u16).bits, 0o000_000_377_u32);
 }
 
diff --git a/base/src/onescomplement/signed/tests36.rs b/base/src/onescomplement/signed/tests36.rs
@@ -66,10 +66,7 @@ fn test_i16_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
diff --git a/base/src/onescomplement/signed/tests5.rs b/base/src/onescomplement/signed/tests5.rs
@@ -17,10 +17,7 @@ fn test_i8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
diff --git a/base/src/onescomplement/signed/tests9.rs b/base/src/onescomplement/signed/tests9.rs
@@ -55,10 +55,7 @@ fn test_i8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -68,8 +65,8 @@ fn test_i8_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -83,10 +80,7 @@ fn test_u8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -96,8 +90,8 @@ fn test_u8_round_tripping() {
             }
             Err(e) => {
                 panic!(
-		    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
-		    i, &q, e);
+                    "Unexpected overflow when round-tripping  {}->{:?}-> [conversion to i8 failed with error {}]",
+                    i, &q, e);
             }
         }
     }
@@ -319,8 +313,7 @@ fn test_wrapping_add() {
 
             assert_eq!(
                 expected, got,
-                "Expected {} + {} = {}, got {:?} + {:?} = {}",
-                left, right, expected, left_operand, right_operand, got
+                "Expected {left} + {right} = {expected}, got {left_operand:?} + {right_operand:?} = {got}",
             );
         }
     }
@@ -339,8 +332,7 @@ fn test_wrapping_sub() {
 
             assert_eq!(
                 expected, got,
-                "Expected {} + {} = {}, got {:?} + {:?} = {}",
-                left, right, expected, left_operand, right_operand, got
+                "Expected {left} + {right} = {expected}, got {left_operand:?} + {right_operand:?} = {got}",
             );
         }
     }
diff --git a/base/src/onescomplement/unsigned/tests.rs b/base/src/onescomplement/unsigned/tests.rs
@@ -69,10 +69,7 @@ fn test_i8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -97,10 +94,7 @@ fn test_u8_round_tripping() {
         if let Some(qprev) = prev {
             assert!(
                 q > qprev,
-                "failed to round-trip {}: {:?} should be greater than {:?}",
-                i,
-                q,
-                qprev
+                "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",
             );
         }
         prev = Some(q);
@@ -151,7 +145,7 @@ fn test_unsigned9bit_zero_values() {
     const CAREFUL_NOW: Unsigned9Bit = Unsigned9Bit {
         bits: 0b111_111_111_u16,
     };
-    assert_eq!(u16::try_from(CAREFUL_NOW), Ok(0o777));
+    assert_eq!(u16::from(CAREFUL_NOW), 0o777);
 }
 
 #[test]
diff --git a/base/src/splay.rs b/base/src/splay.rs
@@ -147,17 +147,15 @@ fn round_trip(input: Unsigned36Bit) -> Result<(), String> {
     for (i, component) in unsplayed.into_iter().enumerate() {
         let next = cycle_and_splay(output, component);
         println!(
-            "round_trip: splay iteration {}: value {:03o} changed word from {:012o} to {:012o}",
-            i, component, output, next
+            "round_trip: splay iteration {i}: value {component:03o} changed word from {output:012o} to {next:012o}",
         );
         output = next;
     }
     dbg!(&output);
     if input == output {
         Ok(())
     } else {
-        Err(format!("mismatch: input word {:012o} unsplayed to {:?}, which splayed to {:012o}, which doesn't match",
-                    input, unsplayed, output))
+        Err(format!("mismatch: input word {input:012o} unsplayed to {unsplayed:?}, which splayed to {output:012o}, which doesn't match",))
     }
 }
 
@@ -176,7 +174,7 @@ fn test_round_trip_selected() {
         Unsigned36Bit::from(0o23574373_u32),
     ] {
         if let Err(e) = round_trip(value) {
-            panic!("round_trip failed for {:012o}: {}", value, e);
+            panic!("round_trip failed for {value:012o}: {e}");
         }
     }
 }
@@ -186,7 +184,7 @@ fn test_round_trip_bitcycle() {
     for bitpos in 0..36 {
         let input: Unsigned36Bit = Unsigned36Bit::ONE.shl(bitpos);
         if let Err(e) = round_trip(input) {
-            panic!("round_trip failed for {:012o}: {}", input, e);
+            panic!("round_trip failed for {input:012o}: {e}");
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -138,8 +138,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {`
`138`	`138`	`) => {`
`139`	`139`	`write!(`
`140`	`140`	`f,`
`141`		`- "cannot convert code {:#o} from Lincoln Writer character set to Unicode, because it has no printable representation",`
`142`		`- n`
	`141`	`+ "cannot convert code {n:#o} from Lincoln Writer character set to Unicode, because it has no printable representation",`
`143`	`142`	`)`
`144`	`143`	`}`
`145`	`144`	`LincolnToUnicodeStrictConversionFailure::CannotSubscript(`
`@@ -148,9 +147,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {`
`148`	`147`	`) => {`
`149`	`148`	`write!(`
`150`	`149`	`f,`
`151`		`- "cannot convert {:#o} from Lincoln Writer character set to Unicode, because Unicode has no subscript form of '{}'",`
`152`		`- u,`
`153`		`- ch`
	`150`	`+ "cannot convert {u:#o} from Lincoln Writer character set to Unicode, because Unicode has no subscript form of '{ch}'",`
`154`	`151`	`)`
`155`	`152`	`}`
`156`	`153`	`LincolnToUnicodeStrictConversionFailure::CannotSuperscript(`
`@@ -159,9 +156,7 @@ impl Display for LincolnToUnicodeStrictConversionFailure {`
`159`	`156`	`) => {`
`160`	`157`	`write!(`
`161`	`158`	`f,`
`162`		`- "cannot convert {:#o} from Lincoln Writer character set to Unicode, because Unicode has no superscript form of '{}'",`
`163`		`- u,`
`164`		`- ch`
	`159`	`+ "cannot convert {u:#o} from Lincoln Writer character set to Unicode, because Unicode has no superscript form of '{ch}'",`
`165`	`160`	`)`
`166`	`161`	`}`
`167`	`162`	`}`
`@@ -620,8 +615,7 @@ impl Display for UnicodeToLincolnConversionFailure {`
`620`	`615`	`UnicodeToLincolnConversionFailure::NoMapping(ch) => {`
`621`	`616`	`write!(`
`622`	`617`	`f,`
`623`		`- "there is no mapping for '{}' from Unicode to Lincoln Writer character set",`
`624`		`- ch,`
	`618`	`+ "there is no mapping for '{ch}' from Unicode to Lincoln Writer character set",`
`625`	`619`	`)`
`626`	`620`	`}`
`627`	`621`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,11 +77,11 @@ fn round_trip() {`
`77`	`77`	`assert_eq!(input, s);`
`78`	`78`	`}`
`79`	`79`	`Err(e) => {`
`80`		`- panic!("failed to convert back to unicode: {}", e);`
	`80`	`+ panic!("failed to convert back to unicode: {e}");`
`81`	`81`	`}`
`82`	`82`	`},`
`83`	`83`	`Err(e) => {`
`84`		`- panic!("failed to convert [{}] to Lincoln: {}", input, e);`
	`84`	`+ panic!("failed to convert [{input}] to Lincoln: {e}");`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,8 +139,8 @@ impl From<Instruction> for Unsigned36Bit {`
`139`	`139`	`impl Debug for Instruction {`
`140`	`140`	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {`
`141`	`141`	`let lhs = match SymbolicInstruction::try_from(self) {`
`142`		`- Ok(sym) => format!("{}", sym),`
`143`		`- Err(e) => format!("(invalid instruction: {})", e),`
	`142`	`+ Ok(sym) => format!("{sym}"),`
	`143`	`+ Err(e) => format!("(invalid instruction: {e})"),`
`144`	`144`	`};`
`145`	`145`	`write!(f, "{:<40} {}", lhs, self.0)`
`146`	`146`	`}`
`@@ -510,7 +510,7 @@ impl Debug for DisassemblyFailure {`
`510`	`510`	`n`
`511`	`511`	`}`
`512`	`512`	`};`
`513`		`- write!(f, "(0{:o})", opcode)`
	`513`	`+ write!(f, "(0{opcode:o})")`
`514`	`514`	`}`
`515`	`515`	`}`
`516`	`516`
Original file line number	Diff line number	Diff line change
`@@ -109,10 +109,10 @@ impl Octal for OperandAddress {`
`109`	`109`	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {`
`110`	`110`	`match self {`
`111`	`111`	`OperandAddress::Direct(addr) => {`
`112`		`- write!(f, "{:o}", addr)`
	`112`	`+ write!(f, "{addr:o}")`
`113`	`113`	`}`
`114`	`114`	`OperandAddress::Deferred(addr) => {`
`115`		`- write!(f, "[{:o}]", addr)`
	`115`	`+ write!(f, "[{addr:o}]")`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`}`
`@@ -130,20 +130,20 @@ impl Display for DisassemblyFailure {`
`130`	`130`	`n`
`131`	`131`	`}`
`132`	`132`	`};`
`133`		`- write!(f, " {:03o}", opcode)`
	`133`	`+ write!(f, " {opcode:03o}")`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`fn octal_superscript_u8(n: u8) -> Result<String, NoSuperscriptKnown> {`
`138`		`- format!("{:o}", n).chars().map(superscript_char).collect()`
	`138`	`+ format!("{n:o}").chars().map(superscript_char).collect()`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`fn subscript(s: &str) -> Result<String, NoSubscriptKnown> {`
`142`	`142`	`s.chars().map(subscript_char).collect()`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`fn octal_subscript_number(n: u8) -> String {`
`146`		`- subscript(&format!("{:o}", n)).unwrap()`
	`146`	`+ subscript(&format!("{n:o}")).unwrap()`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`fn write_opcode(op: Opcode, cfg: Unsigned5Bit, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {`
`@@ -204,7 +204,7 @@ fn write_opcode(op: Opcode, cfg: Unsigned5Bit, f: &mut Formatter<'_>) -> Result<`
`204`	`204`	`0o14 => "SUR",`
`205`	`205`	`_ => "SKM",`
`206`	`206`	`}),`
`207`		`- _ => write!(f, "{}", op),`
	`207`	`+ _ => write!(f, "{op}"),`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
Original file line number	Diff line number	Diff line change
`@@ -86,10 +86,7 @@ fn test_i8_round_tripping() {`
`86`	`86`	`if let Some(qprev) = prev {`
`87`	`87`	`assert!(`
`88`	`88`	`q > qprev,`
`89`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`90`		`- i,`
`91`		`- q,`
`92`		`- qprev`
	`89`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`93`	`90`	`);`
`94`	`91`	`}`
`95`	`92`	`prev = Some(q);`
`@@ -99,8 +96,8 @@ fn test_i8_round_tripping() {`
`99`	`96`	`}`
`100`	`97`	`Err(e) => {`
`101`	`98`	`panic!(`
`102`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`103`		`- i, &q, e);`
	`99`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`100`	`+ i, &q, e);`
`104`	`101`	`}`
`105`	`102`	`}`
`106`	`103`	`}`
`@@ -114,10 +111,7 @@ fn test_i16_round_tripping() {`
`114`	`111`	`if let Some(qprev) = prev {`
`115`	`112`	`assert!(`
`116`	`113`	`q > qprev,`
`117`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`118`		`- i,`
`119`		`- q,`
`120`		`- qprev`
	`114`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`121`	`115`	`);`
`122`	`116`	`}`
`123`	`117`	`prev = Some(q);`
`@@ -127,8 +121,8 @@ fn test_i16_round_tripping() {`
`127`	`121`	`}`
`128`	`122`	`Err(e) => {`
`129`	`123`	`panic!(`
`130`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`131`		`- i, &q, e);`
	`124`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`125`	`+ i, &q, e);`
`132`	`126`	`}`
`133`	`127`	`}`
`134`	`128`	`}`
`@@ -142,10 +136,7 @@ fn test_u8_round_tripping() {`
`142`	`136`	`if let Some(qprev) = prev {`
`143`	`137`	`assert!(`
`144`	`138`	`q > qprev,`
`145`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`146`		`- i,`
`147`		`- q,`
`148`		`- qprev`
	`139`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`149`	`140`	`);`
`150`	`141`	`}`
`151`	`142`	`prev = Some(q);`
`@@ -155,8 +146,8 @@ fn test_u8_round_tripping() {`
`155`	`146`	`}`
`156`	`147`	`Err(e) => {`
`157`	`148`	`panic!(`
`158`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`159`		`- i, &q, e);`
	`149`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`150`	`+ i, &q, e);`
`160`	`151`	`}`
`161`	`152`	`}`
`162`	`153`	`}`
`@@ -170,10 +161,7 @@ fn test_u16_round_tripping() {`
`170`	`161`	`if let Some(qprev) = prev {`
`171`	`162`	`assert!(`
`172`	`163`	`q > qprev,`
`173`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`174`		`- i,`
`175`		`- q,`
`176`		`- qprev`
	`164`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`177`	`165`	`);`
`178`	`166`	`}`
`179`	`167`	`prev = Some(q);`
`@@ -183,8 +171,8 @@ fn test_u16_round_tripping() {`
`183`	`171`	`}`
`184`	`172`	`Err(e) => {`
`185`	`173`	`panic!(`
`186`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`187`		`- i, &q, e);`
	`174`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`175`	`+ i, &q, e);`
`188`	`176`	`}`
`189`	`177`	`}`
`190`	`178`	`}`
`@@ -322,8 +310,8 @@ fn test_from_signed18bit_to_i16() {`
`322`	`310`
`323`	`311`	`#[test]`
`324`	`312`	`fn test_from_u16_to_signed18bit() {`
`325`		`- assert_eq!(Signed18Bit::try_from(0_u16), Ok(Signed18Bit::ZERO));`
`326`		`- assert_eq!(Signed18Bit::try_from(1_u16), Ok(Signed18Bit::ONE));`
	`313`	`+ assert_eq!(Signed18Bit::from(0_u16), Signed18Bit::ZERO);`
	`314`	`+ assert_eq!(Signed18Bit::from(1_u16), Signed18Bit::ONE);`
`327`	`315`	`assert_eq!(Signed18Bit::from(0o377_u16).bits, 0o000_000_377_u32);`
`328`	`316`	`}`
`329`	`317`
Original file line number	Diff line number	Diff line change
`@@ -55,10 +55,7 @@ fn test_i8_round_tripping() {`
`55`	`55`	`if let Some(qprev) = prev {`
`56`	`56`	`assert!(`
`57`	`57`	`q > qprev,`
`58`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`59`		`- i,`
`60`		`- q,`
`61`		`- qprev`
	`58`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`62`	`59`	`);`
`63`	`60`	`}`
`64`	`61`	`prev = Some(q);`
`@@ -68,8 +65,8 @@ fn test_i8_round_tripping() {`
`68`	`65`	`}`
`69`	`66`	`Err(e) => {`
`70`	`67`	`panic!(`
`71`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`72`		`- i, &q, e);`
	`68`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`69`	`+ i, &q, e);`
`73`	`70`	`}`
`74`	`71`	`}`
`75`	`72`	`}`
`@@ -83,10 +80,7 @@ fn test_u8_round_tripping() {`
`83`	`80`	`if let Some(qprev) = prev {`
`84`	`81`	`assert!(`
`85`	`82`	`q > qprev,`
`86`		`- "failed to round-trip {}: {:?} should be greater than {:?}",`
`87`		`- i,`
`88`		`- q,`
`89`		`- qprev`
	`83`	`+ "failed to round-trip {i}: {q:?} should be greater than {qprev:?}",`
`90`	`84`	`);`
`91`	`85`	`}`
`92`	`86`	`prev = Some(q);`
`@@ -96,8 +90,8 @@ fn test_u8_round_tripping() {`
`96`	`90`	`}`
`97`	`91`	`Err(e) => {`
`98`	`92`	`panic!(`
`99`		`- "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
`100`		`- i, &q, e);`
	`93`	`+ "Unexpected overflow when round-tripping {}->{:?}-> [conversion to i8 failed with error {}]",`
	`94`	`+ i, &q, e);`
`101`	`95`	`}`
`102`	`96`	`}`
`103`	`97`	`}`
`@@ -319,8 +313,7 @@ fn test_wrapping_add() {`
`319`	`313`
`320`	`314`	`assert_eq!(`
`321`	`315`	`expected, got,`
`322`		`- "Expected {} + {} = {}, got {:?} + {:?} = {}",`
`323`		`- left, right, expected, left_operand, right_operand, got`
	`316`	`+ "Expected {left} + {right} = {expected}, got {left_operand:?} + {right_operand:?} = {got}",`
`324`	`317`	`);`
`325`	`318`	`}`
`326`	`319`	`}`
`@@ -339,8 +332,7 @@ fn test_wrapping_sub() {`
`339`	`332`
`340`	`333`	`assert_eq!(`
`341`	`334`	`expected, got,`
`342`		`- "Expected {} + {} = {}, got {:?} + {:?} = {}",`
`343`		`- left, right, expected, left_operand, right_operand, got`
	`335`	`+ "Expected {left} + {right} = {expected}, got {left_operand:?} + {right_operand:?} = {got}",`
`344`	`336`	`);`
`345`	`337`	`}`
`346`	`338`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,17 +147,15 @@ fn round_trip(input: Unsigned36Bit) -> Result<(), String> {`
`147`	`147`	`for (i, component) in unsplayed.into_iter().enumerate() {`
`148`	`148`	`let next = cycle_and_splay(output, component);`
`149`	`149`	`println!(`
`150`		`- "round_trip: splay iteration {}: value {:03o} changed word from {:012o} to {:012o}",`
`151`		`- i, component, output, next`
	`150`	`+ "round_trip: splay iteration {i}: value {component:03o} changed word from {output:012o} to {next:012o}",`
`152`	`151`	`);`
`153`	`152`	`output = next;`
`154`	`153`	`}`
`155`	`154`	`dbg!(&output);`
`156`	`155`	`if input == output {`
`157`	`156`	`Ok(())`
`158`	`157`	`} else {`
`159`		`- Err(format!("mismatch: input word {:012o} unsplayed to {:?}, which splayed to {:012o}, which doesn't match",`
`160`		`- input, unsplayed, output))`
	`158`	`+ Err(format!("mismatch: input word {input:012o} unsplayed to {unsplayed:?}, which splayed to {output:012o}, which doesn't match",))`
`161`	`159`	`}`
`162`	`160`	`}`
`163`	`161`
`@@ -176,7 +174,7 @@ fn test_round_trip_selected() {`
`176`	`174`	`Unsigned36Bit::from(0o23574373_u32),`
`177`	`175`	`] {`
`178`	`176`	`if let Err(e) = round_trip(value) {`
`179`		`- panic!("round_trip failed for {:012o}: {}", value, e);`
	`177`	`+ panic!("round_trip failed for {value:012o}: {e}");`
`180`	`178`	`}`
`181`	`179`	`}`
`182`	`180`	`}`
`@@ -186,7 +184,7 @@ fn test_round_trip_bitcycle() {`
`186`	`184`	`for bitpos in 0..36 {`
`187`	`185`	`let input: Unsigned36Bit = Unsigned36Bit::ONE.shl(bitpos);`
`188`	`186`	`if let Err(e) = round_trip(input) {`
`189`		`- panic!("round_trip failed for {:012o}: {}", input, e);`
	`187`	`+ panic!("round_trip failed for {input:012o}: {e}");`
`190`	`188`	`}`
`191`	`189`	`}`
`192`	`190`	`}`