Use captured identifiers in format strings for tests

This is only used in test files, so I don't have to bump the MSRV. This
feature was only stabilized in 1.58.

Author: LukasKalbertodt

src/float/tests.rs

@@ -175,7 +175,7 @@ fn non_standard_suffixes() {
 
         let lit = match Literal::parse(input) {
             Ok(Literal::Float(f)) => f,
-            other => panic!("Expected float literal, but got {:?} for '{}'", other, input),
+            other => panic!("Expected float literal, but got {other:?} for '{input}'"),
         };
         assert_eq!(lit.integer_part(), integer_part);
         assert_eq!(lit.fractional_part(), fractional_part);

src/integer/tests.rs

@@ -36,12 +36,8 @@ fn check<T: FromIntegerLiteral + PartialEq + Debug + Display>(
         .value::<T>()
         .unwrap_or_else(|| panic!("unexpected overflow in `IntegerLit::value` for `{}`", input));
     if actual_value != value {
-        panic!(
-            "Parsing int literal `{}` should give value `{}`, but actually resulted in `{}`",
-            input,
-            value,
-            actual_value,
-        );
+        panic!("Parsing int literal `{input}` should give value `{value}`, \
+            but actually resulted in `{actual_value}`");
     }
 }
 

src/test_util.rs

@@ -13,29 +13,17 @@ pub(crate) fn assert_parse_ok_eq<T: PartialEq + Debug + Display>(
     match result {
         Ok(actual) if actual == expected => {
             if actual.to_string() != input {
-                panic!(
-                    "formatting does not yield original input `{}`: {:?}",
-                    input,
-                    actual,
-                );
+                panic!("formatting does not yield original input `{input}`: {actual:?}");
             }
         }
         Ok(actual) => {
-            panic!(
-                "unexpected parsing result (with `{}`) for `{}`:\nactual:    {:?}\nexpected:  {:?}",
-                parse_method,
-                input,
-                actual,
-                expected,
-            );
+            panic!("unexpected parsing result (with `{parse_method}`) for `{input}`:\n\
+                actual:    {actual:?}\n\
+                expected:  {expected:?}");
         }
         Err(e) => {
-            panic!(
-                "expected `{}` to be parsed (with `{}`) successfully, but it failed: {:?}",
-                input,
-                parse_method,
-                e,
-            );
+            panic!("expected `{input}` to be parsed (with `{parse_method}`) successfully, \
+                but it failed: {e:?}");
         }
     }
 }
@@ -71,17 +59,13 @@ where
 
     match T::try_from(pm_lit) {
         Err(e) => {
-            panic!("Trying to convert proc_macro2::Literal to {} results in error: {}", t_name, e);
+            panic!("Trying to convert proc_macro2::Literal to {t_name} results in error: {e}");
         }
         Ok(res) => {
             if res != ours {
-                panic!(
-                    "Converting proc_macro2::Literal to {} has unexpected result:\
-                        \nactual:    {:?}\nexpected:  {:?}",
-                    t_name,
-                    res,
-                    ours,
-                );
+                panic!("Converting proc_macro2::Literal to {t_name} has unexpected result:\n\
+                    actual:    {res:?}\n\
+                    expected:  {ours:?}");
             }
         }
     }