Fix beta clippy lints (#7154)

lewiszlw · lewiszlw · commit 0d2cdb450d49 · 2023-01-11T09:51:22.000Z
# Objective - When I run `cargo run -p ci` for my pr locally using latest beta toolchain, the ci failed due to [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args) and [needless_lifetimes](https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes) lints ## Solution - Fix lints according to clippy suggestions.
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
@@ -872,8 +872,7 @@ impl App {
         match self.add_boxed_plugin(Box::new(plugin)) {
             Ok(app) => app,
             Err(AppError::DuplicatePlugin { plugin_name }) => panic!(
-                "Error adding plugin {}: : plugin was already added in application",
-                plugin_name
+                "Error adding plugin {plugin_name}: : plugin was already added in application"
             ),
         }
     }
diff --git a/crates/bevy_asset/src/reflect.rs b/crates/bevy_asset/src/reflect.rs
@@ -94,13 +94,13 @@ impl ReflectAsset {
     }
 
     /// Equivalent of [`Assets::add`]
-    pub fn add<'w>(&self, world: &'w mut World, value: &dyn Reflect) -> HandleUntyped {
+    pub fn add(&self, world: &mut World, value: &dyn Reflect) -> HandleUntyped {
         (self.add)(world, value)
     }
     /// Equivalent of [`Assets::set`]
-    pub fn set<'w>(
+    pub fn set(
         &self,
-        world: &'w mut World,
+        world: &mut World,
         handle: HandleUntyped,
         value: &dyn Reflect,
     ) -> HandleUntyped {
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
@@ -86,8 +86,7 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
                         return Err(Error::new_spanned(
                             m.lit,
                             format!(
-                                "Invalid storage type `{}`, expected '{}' or '{}'.",
-                                s, TABLE, SPARSE_SET
+                                "Invalid storage type `{s}`, expected '{TABLE}' or '{SPARSE_SET}'.",
                             ),
                         ))
                     }
diff --git a/crates/bevy_ecs/macros/src/fetch.rs b/crates/bevy_ecs/macros/src/fetch.rs
@@ -52,8 +52,7 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                         fetch_struct_attributes.is_mutable = true;
                     } else {
                         panic!(
-                            "The `{}` attribute is expected to have no value or arguments",
-                            MUTABLE_ATTRIBUTE_NAME
+                            "The `{MUTABLE_ATTRIBUTE_NAME}` attribute is expected to have no value or arguments",
                         );
                     }
                 } else if ident == DERIVE_ATTRIBUTE_NAME {
@@ -63,8 +62,7 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                             .extend(meta_list.nested.iter().cloned());
                     } else {
                         panic!(
-                            "Expected a structured list within the `{}` attribute",
-                            DERIVE_ATTRIBUTE_NAME
+                            "Expected a structured list within the `{DERIVE_ATTRIBUTE_NAME}` attribute",
                         );
                     }
                 } else {
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
@@ -731,8 +731,7 @@ unsafe fn initialize_bundle(
     deduped.dedup();
     assert!(
         deduped.len() == component_ids.len(),
-        "Bundle {} has duplicate components",
-        bundle_type_name
+        "Bundle {bundle_type_name} has duplicate components",
     );
 
     BundleInfo { id, component_ids }
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
@@ -224,10 +224,7 @@ impl Schedule {
         // of the game. Closures inherit generic parameters from their enclosing function.
         #[cold]
         fn stage_not_found(stage_label: &dyn Debug) -> ! {
-            panic!(
-                "Stage '{:?}' does not exist or is not a SystemStage",
-                stage_label
-            )
+            panic!("Stage '{stage_label:?}' does not exist or is not a SystemStage",)
         }
 
         let label = stage_label.as_label();
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
@@ -287,10 +287,9 @@ impl SystemStage {
                     .then(|| descriptor.system.name())
                 {
                     panic!(
-                        "The system {} has a run criteria, but its `SystemSet` also has a run \
+                        "The system {name} has a run criteria, but its `SystemSet` also has a run \
                         criteria. This is not supported. Consider moving the system into a \
-                        different `SystemSet` or calling `add_system()` instead.",
-                        name
+                        different `SystemSet` or calling `add_system()` instead."
                     )
                 }
             }
@@ -459,8 +458,7 @@ impl SystemStage {
                         writeln!(message, " - {}", nodes[*index].name()).unwrap();
                         writeln!(
                             message,
-                            "    wants to be after (because of labels: {:?})",
-                            labels,
+                            "    wants to be after (because of labels: {labels:?})",
                         )
                         .unwrap();
                     }
@@ -565,10 +563,7 @@ impl SystemStage {
             if let RunCriteriaInner::Piped { input: parent, .. } = &mut criteria.inner {
                 let label = &criteria.after[0];
                 *parent = *labels.get(label).unwrap_or_else(|| {
-                    panic!(
-                        "Couldn't find run criteria labelled {:?} to pipe from.",
-                        label
-                    )
+                    panic!("Couldn't find run criteria labelled {label:?} to pipe from.",)
                 });
             }
         }
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -282,8 +282,7 @@ impl<'w, 's> Commands<'w, 's> {
     pub fn entity<'a>(&'a mut self, entity: Entity) -> EntityCommands<'w, 's, 'a> {
         self.get_entity(entity).unwrap_or_else(|| {
             panic!(
-                "Attempting to create an EntityCommands for entity {:?}, which doesn't exist.",
-                entity
+                "Attempting to create an EntityCommands for entity {entity:?}, which doesn't exist.",
             )
         })
     }
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
@@ -250,8 +250,7 @@ fn assert_component_access_compatibility(
         .map(|component_id| world.components.get_info(component_id).unwrap().name())
         .collect::<Vec<&str>>();
     let accesses = conflicting_components.join(", ");
-    panic!("error[B0001]: Query<{}, {}> in system {} accesses component(s) {} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`.",
-           query_type, filter_type, system_name, accesses);
+    panic!("error[B0001]: Query<{query_type}, {filter_type}> in system {system_name} accesses component(s) {accesses} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`.");
 }
 
 /// A collection of potentially conflicting [`SystemParam`]s allowed by disjoint access.
diff --git a/crates/bevy_input/src/gamepad.rs b/crates/bevy_input/src/gamepad.rs
@@ -1256,8 +1256,7 @@ mod tests {
         let actual = settings.filter(new_value, old_value);
         assert_eq!(
             expected, actual,
-            "Testing filtering for {:?} with new_value = {:?}, old_value = {:?}",
-            settings, new_value, old_value
+            "Testing filtering for {settings:?} with new_value = {new_value:?}, old_value = {old_value:?}",
         );
     }
 
@@ -1312,8 +1311,7 @@ mod tests {
         let actual = settings.filter(new_value, old_value);
         assert_eq!(
             expected, actual,
-            "Testing filtering for {:?} with new_value = {:?}, old_value = {:?}",
-            settings, new_value, old_value
+            "Testing filtering for {settings:?} with new_value = {new_value:?}, old_value = {old_value:?}",
         );
     }
 
@@ -1398,8 +1396,7 @@ mod tests {
 
             assert_eq!(
                 expected, actual,
-                "testing ButtonSettings::is_pressed() for value: {}",
-                value
+                "testing ButtonSettings::is_pressed() for value: {value}",
             );
         }
     }
@@ -1424,8 +1421,7 @@ mod tests {
 
             assert_eq!(
                 expected, actual,
-                "testing ButtonSettings::is_released() for value: {}",
-                value
+                "testing ButtonSettings::is_released() for value: {value}",
             );
         }
     }
@@ -1450,8 +1446,7 @@ mod tests {
                 }
                 Err(_) => {
                     panic!(
-                        "ButtonSettings::new({}, {}) should be valid ",
-                        press_threshold, release_threshold
+                        "ButtonSettings::new({press_threshold}, {release_threshold}) should be valid"
                     );
                 }
             }
@@ -1476,8 +1471,7 @@ mod tests {
             match bs {
                 Ok(_) => {
                     panic!(
-                        "ButtonSettings::new({}, {}) should be invalid",
-                        press_threshold, release_threshold
+                        "ButtonSettings::new({press_threshold}, {release_threshold}) should be invalid"
                     );
                 }
                 Err(err_code) => match err_code {
diff --git a/crates/bevy_macro_utils/src/attrs.rs b/crates/bevy_macro_utils/src/attrs.rs
@@ -24,10 +24,7 @@ pub fn get_lit_str(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<&syn::LitSt
     } else {
         Err(syn::Error::new_spanned(
             lit,
-            format!(
-                "expected {} attribute to be a string: `{} = \"...\"`",
-                attr_name, attr_name
-            ),
+            format!("expected {attr_name} attribute to be a string: `{attr_name} = \"...\"`"),
         ))
     }
 }
@@ -38,10 +35,7 @@ pub fn get_lit_bool(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<bool> {
     } else {
         Err(syn::Error::new_spanned(
             lit,
-            format!(
-                "expected {} attribute to be a bool value, `true` or `false`: `{} = ...`",
-                attr_name, attr_name
-            ),
+            format!("expected {attr_name} attribute to be a bool value, `true` or `false`: `{attr_name} = ...`"),
         ))
     }
 }
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
@@ -1190,7 +1190,7 @@ pub fn prepare_lights(
                 .spawn((
                     ShadowView {
                         depth_texture_view,
-                        pass_name: format!("shadow pass directional light {}", light_index),
+                        pass_name: format!("shadow pass directional light {light_index}"),
                     },
                     ExtractedView {
                         viewport: UVec4::new(
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/trait_reflection.rs b/crates/bevy_reflect/bevy_reflect_derive/src/trait_reflection.rs
@@ -35,21 +35,16 @@ pub(crate) fn reflect_trait(_args: &TokenStream, input: TokenStream) -> TokenStr
     let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
 
     let struct_doc = format!(
-        " A type generated by the #[reflect_trait] macro for the `{}` trait.\n\n This allows casting from `dyn Reflect` to `dyn {}`.",
-        trait_ident,
-        trait_ident
+        " A type generated by the #[reflect_trait] macro for the `{trait_ident}` trait.\n\n This allows casting from `dyn Reflect` to `dyn {trait_ident}`.",
     );
     let get_doc = format!(
-        " Downcast a `&dyn Reflect` type to `&dyn {}`.\n\n If the type cannot be downcast, `None` is returned.",
-        trait_ident,
+        " Downcast a `&dyn Reflect` type to `&dyn {trait_ident}`.\n\n If the type cannot be downcast, `None` is returned.",
     );
     let get_mut_doc = format!(
-        " Downcast a `&mut dyn Reflect` type to `&mut dyn {}`.\n\n If the type cannot be downcast, `None` is returned.",
-        trait_ident,
+        " Downcast a `&mut dyn Reflect` type to `&mut dyn {trait_ident}`.\n\n If the type cannot be downcast, `None` is returned.",
     );
     let get_box_doc = format!(
-        " Downcast a `Box<dyn Reflect>` type to `Box<dyn {}>`.\n\n If the type cannot be downcast, this will return `Err(Box<dyn Reflect>)`.",
-        trait_ident,
+        " Downcast a `Box<dyn Reflect>` type to `Box<dyn {trait_ident}>`.\n\n If the type cannot be downcast, this will return `Err(Box<dyn Reflect>)`.",
     );
 
     TokenStream::from(quote! {
diff --git a/crates/bevy_reflect/src/serde/de.rs b/crates/bevy_reflect/src/serde/de.rs
@@ -467,16 +467,14 @@ impl<'a, 'de> DeserializeSeed<'de> for TypedReflectDeserializer<'a> {
             TypeInfo::Value(_) => {
                 // This case should already be handled
                 Err(de::Error::custom(format_args!(
-                    "the TypeRegistration for {} doesn't have ReflectDeserialize",
-                    type_name
+                    "the TypeRegistration for {type_name} doesn't have ReflectDeserialize",
                 )))
             }
             TypeInfo::Dynamic(_) => {
                 // We could potentially allow this but we'd have no idea what the actual types of the
                 // fields are and would rely on the deserializer to determine them (e.g. `i32` vs `i64`)
                 Err(de::Error::custom(format_args!(
-                    "cannot deserialize arbitrary dynamic type {}",
-                    type_name
+                    "cannot deserialize arbitrary dynamic type {type_name}",
                 )))
             }
         }
@@ -1080,10 +1078,7 @@ fn get_registration<'a, E: Error>(
     registry: &'a TypeRegistry,
 ) -> Result<&'a TypeRegistration, E> {
     let registration = registry.get(type_id).ok_or_else(|| {
-        Error::custom(format_args!(
-            "no registration found for type `{}`",
-            type_name
-        ))
+        Error::custom(format_args!("no registration found for type `{type_name}`",))
     })?;
     Ok(registration)
 }
diff --git a/crates/bevy_reflect/src/serde/ser.rs b/crates/bevy_reflect/src/serde/ser.rs
@@ -56,8 +56,7 @@ fn get_type_info<E: Error>(
         TypeInfo::Dynamic(..) => match registry.get_with_name(type_name) {
             Some(registration) => Ok(registration.type_info()),
             None => Err(Error::custom(format_args!(
-                "no registration found for dynamic type with name {}",
-                type_name
+                "no registration found for dynamic type with name {type_name}",
             ))),
         },
         info => Ok(info),
@@ -197,8 +196,7 @@ impl<'a> Serialize for StructSerializer<'a> {
             TypeInfo::Struct(struct_info) => struct_info,
             info => {
                 return Err(Error::custom(format_args!(
-                    "expected struct type but received {:?}",
-                    info
+                    "expected struct type but received {info:?}"
                 )));
             }
         };
@@ -247,8 +245,7 @@ impl<'a> Serialize for TupleStructSerializer<'a> {
             TypeInfo::TupleStruct(tuple_struct_info) => tuple_struct_info,
             info => {
                 return Err(Error::custom(format_args!(
-                    "expected tuple struct type but received {:?}",
-                    info
+                    "expected tuple struct type but received {info:?}"
                 )));
             }
         };
@@ -296,8 +293,7 @@ impl<'a> Serialize for EnumSerializer<'a> {
             TypeInfo::Enum(enum_info) => enum_info,
             info => {
                 return Err(Error::custom(format_args!(
-                    "expected enum type but received {:?}",
-                    info
+                    "expected enum type but received {info:?}"
                 )));
             }
         };
@@ -308,8 +304,7 @@ impl<'a> Serialize for EnumSerializer<'a> {
             .variant_at(variant_index as usize)
             .ok_or_else(|| {
                 Error::custom(format_args!(
-                    "variant at index `{}` does not exist",
-                    variant_index
+                    "variant at index `{variant_index}` does not exist",
                 ))
             })?;
         let variant_name = variant_info.name();
@@ -333,8 +328,7 @@ impl<'a> Serialize for EnumSerializer<'a> {
                     VariantInfo::Struct(struct_info) => struct_info,
                     info => {
                         return Err(Error::custom(format_args!(
-                            "expected struct variant type but received {:?}",
-                            info
+                            "expected struct variant type but received {info:?}",
                         )));
                     }
                 };
diff --git a/crates/bevy_render/src/texture/basis.rs b/crates/bevy_render/src/texture/basis.rs
diff --git a/crates/bevy_render/src/texture/dds.rs b/crates/bevy_render/src/texture/dds.rs
diff --git a/crates/bevy_render/src/texture/ktx2.rs b/crates/bevy_render/src/texture/ktx2.rs
diff --git a/crates/bevy_render/src/view/window.rs b/crates/bevy_render/src/view/window.rs
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
diff --git a/crates/bevy_transform/src/systems.rs b/crates/bevy_transform/src/systems.rs
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs

Original file line number	Diff line number	Diff line change
`@@ -872,8 +872,7 @@ impl App {`
`872`	`872`	`match self.add_boxed_plugin(Box::new(plugin)) {`
`873`	`873`	`Ok(app) => app,`
`874`	`874`	`Err(AppError::DuplicatePlugin { plugin_name }) => panic!(`
`875`		`- "Error adding plugin {}: : plugin was already added in application",`
`876`		`- plugin_name`
	`875`	`+ "Error adding plugin {plugin_name}: : plugin was already added in application"`
`877`	`876`	`),`
`878`	`877`	`}`
`879`	`878`	`}`
Original file line number	Diff line number	Diff line change
`@@ -287,10 +287,9 @@ impl SystemStage {`
`287`	`287`	`.then(\|\| descriptor.system.name())`
`288`	`288`	`{`
`289`	`289`	`panic!(`
`290`		- "The system {} has a run criteria, but its `SystemSet` also has a run \
	`290`	+ "The system {name} has a run criteria, but its `SystemSet` also has a run \
`291`	`291`	`criteria. This is not supported. Consider moving the system into a \`
`292`		- different `SystemSet` or calling `add_system()` instead.",
`293`		`- name`
	`292`	+ different `SystemSet` or calling `add_system()` instead."
`294`	`293`	`)`
`295`	`294`	`}`
`296`	`295`	`}`
`@@ -459,8 +458,7 @@ impl SystemStage {`
`459`	`458`	`writeln!(message, " - {}", nodes[*index].name()).unwrap();`
`460`	`459`	`writeln!(`
`461`	`460`	`message,`
`462`		`- " wants to be after (because of labels: {:?})",`
`463`		`- labels,`
	`461`	`+ " wants to be after (because of labels: {labels:?})",`
`464`	`462`	`)`
`465`	`463`	`.unwrap();`
`466`	`464`	`}`
`@@ -565,10 +563,7 @@ impl SystemStage {`
`565`	`563`	`if let RunCriteriaInner::Piped { input: parent, .. } = &mut criteria.inner {`
`566`	`564`	`let label = &criteria.after[0];`
`567`	`565`	`parent = labels.get(label).unwrap_or_else(\|\| {`
`568`		`- panic!(`
`569`		`- "Couldn't find run criteria labelled {:?} to pipe from.",`
`570`		`- label`
`571`		`- )`
	`566`	`+ panic!("Couldn't find run criteria labelled {label:?} to pipe from.",)`
`572`	`567`	`});`
`573`	`568`	`}`
`574`	`569`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,8 +282,7 @@ impl<'w, 's> Commands<'w, 's> {`
`282`	`282`	`pub fn entity<'a>(&'a mut self, entity: Entity) -> EntityCommands<'w, 's, 'a> {`
`283`	`283`	`self.get_entity(entity).unwrap_or_else(\|\| {`
`284`	`284`	`panic!(`
`285`		`- "Attempting to create an EntityCommands for entity {:?}, which doesn't exist.",`
`286`		`- entity`
	`285`	`+ "Attempting to create an EntityCommands for entity {entity:?}, which doesn't exist.",`
`287`	`286`	`)`
`288`	`287`	`})`
`289`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,8 +250,7 @@ fn assert_component_access_compatibility(`
`250`	`250`	`.map(\|component_id\| world.components.get_info(component_id).unwrap().name())`
`251`	`251`	`.collect::<Vec<&str>>();`
`252`	`252`	`let accesses = conflicting_components.join(", ");`
`253`		- panic!("error[B0001]: Query<{}, {}> in system {} accesses component(s) {} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`.",
`254`		`- query_type, filter_type, system_name, accesses);`
	`253`	+ panic!("error[B0001]: Query<{query_type}, {filter_type}> in system {system_name} accesses component(s) {accesses} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`.");
`255`	`254`	`}`
`256`	`255`
`257`	`256`	/// A collection of potentially conflicting [`SystemParam`]s allowed by disjoint access.
Original file line number	Diff line number	Diff line change
`@@ -1256,8 +1256,7 @@ mod tests {`
`1256`	`1256`	`let actual = settings.filter(new_value, old_value);`
`1257`	`1257`	`assert_eq!(`
`1258`	`1258`	`expected, actual,`
`1259`		`- "Testing filtering for {:?} with new_value = {:?}, old_value = {:?}",`
`1260`		`- settings, new_value, old_value`
	`1259`	`+ "Testing filtering for {settings:?} with new_value = {new_value:?}, old_value = {old_value:?}",`
`1261`	`1260`	`);`
`1262`	`1261`	`}`
`1263`	`1262`
`@@ -1312,8 +1311,7 @@ mod tests {`
`1312`	`1311`	`let actual = settings.filter(new_value, old_value);`
`1313`	`1312`	`assert_eq!(`
`1314`	`1313`	`expected, actual,`
`1315`		`- "Testing filtering for {:?} with new_value = {:?}, old_value = {:?}",`
`1316`		`- settings, new_value, old_value`
	`1314`	`+ "Testing filtering for {settings:?} with new_value = {new_value:?}, old_value = {old_value:?}",`
`1317`	`1315`	`);`
`1318`	`1316`	`}`
`1319`	`1317`
`@@ -1398,8 +1396,7 @@ mod tests {`
`1398`	`1396`
`1399`	`1397`	`assert_eq!(`
`1400`	`1398`	`expected, actual,`
`1401`		`- "testing ButtonSettings::is_pressed() for value: {}",`
`1402`		`- value`
	`1399`	`+ "testing ButtonSettings::is_pressed() for value: {value}",`
`1403`	`1400`	`);`
`1404`	`1401`	`}`
`1405`	`1402`	`}`
`@@ -1424,8 +1421,7 @@ mod tests {`
`1424`	`1421`
`1425`	`1422`	`assert_eq!(`
`1426`	`1423`	`expected, actual,`
`1427`		`- "testing ButtonSettings::is_released() for value: {}",`
`1428`		`- value`
	`1424`	`+ "testing ButtonSettings::is_released() for value: {value}",`
`1429`	`1425`	`);`
`1430`	`1426`	`}`
`1431`	`1427`	`}`
`@@ -1450,8 +1446,7 @@ mod tests {`
`1450`	`1446`	`}`
`1451`	`1447`	`Err(_) => {`
`1452`	`1448`	`panic!(`
`1453`		`- "ButtonSettings::new({}, {}) should be valid ",`
`1454`		`- press_threshold, release_threshold`
	`1449`	`+ "ButtonSettings::new({press_threshold}, {release_threshold}) should be valid"`
`1455`	`1450`	`);`
`1456`	`1451`	`}`
`1457`	`1452`	`}`
`@@ -1476,8 +1471,7 @@ mod tests {`
`1476`	`1471`	`match bs {`
`1477`	`1472`	`Ok(_) => {`
`1478`	`1473`	`panic!(`
`1479`		`- "ButtonSettings::new({}, {}) should be invalid",`
`1480`		`- press_threshold, release_threshold`
	`1474`	`+ "ButtonSettings::new({press_threshold}, {release_threshold}) should be invalid"`
`1481`	`1475`	`);`
`1482`	`1476`	`}`
`1483`	`1477`	`Err(err_code) => match err_code {`
Original file line number	Diff line number	Diff line change
`@@ -24,10 +24,7 @@ pub fn get_lit_str(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<&syn::LitSt`
`24`	`24`	`} else {`
`25`	`25`	`Err(syn::Error::new_spanned(`
`26`	`26`	`lit,`
`27`		`- format!(`
`28`		- "expected {} attribute to be a string: `{} = \"...\"`",
`29`		`- attr_name, attr_name`
`30`		`- ),`
	`27`	+ format!("expected {attr_name} attribute to be a string: `{attr_name} = \"...\"`"),
`31`	`28`	`))`
`32`	`29`	`}`
`33`	`30`	`}`
`@@ -38,10 +35,7 @@ pub fn get_lit_bool(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<bool> {`
`38`	`35`	`} else {`
`39`	`36`	`Err(syn::Error::new_spanned(`
`40`	`37`	`lit,`
`41`		`- format!(`
`42`		- "expected {} attribute to be a bool value, `true` or `false`: `{} = ...`",
`43`		`- attr_name, attr_name`
`44`		`- ),`
	`38`	+ format!("expected {attr_name} attribute to be a bool value, `true` or `false`: `{attr_name} = ...`"),
`45`	`39`	`))`
`46`	`40`	`}`
`47`	`41`	`}`