chore: fix new clippy warnings causing build errors (#428)

makspll · web-flow · commit 9c5e216deaa1 · 2025-06-29T18:37:10.000Z
diff --git a/Cargo.toml b/Cargo.toml
@@ -147,9 +147,9 @@ codegen-units = 8
 incremental = false
 debug = false
 
-[profile.ephemeral-coverage]
-inherits = "ephemeral-build"
-debug = true
+# [profile.ephemeral-coverage]
+# inherits = "ephemeral-build"
+# debug = true
 
 [profile.release-with-debug]
 inherits = "release"
diff --git a/benches/benchmarks.rs b/benches/benchmarks.rs
@@ -109,7 +109,7 @@ fn script_benchmarks(criterion: &mut Criterion, filter: Option<Regex>) {
     }
 
     for (group, tests) in grouped {
-        println!("Running benchmarks for group: {}", group);
+        println!("Running benchmarks for group: {group}");
         let mut benchmark_group = criterion.benchmark_group(group);
 
         for t in tests {
diff --git a/crates/bevy_mod_scripting_core/src/asset.rs b/crates/bevy_mod_scripting_core/src/asset.rs
@@ -431,7 +431,7 @@ mod tests {
             LoadState::NotLoaded => panic!("Asset not loaded"),
             LoadState::Loaded => {}
             LoadState::Failed(asset_load_error) => {
-                panic!("Asset load failed: {:?}", asset_load_error)
+                panic!("Asset load failed: {asset_load_error:?}")
             }
             _ => panic!("Unexpected load state"),
         }
@@ -532,7 +532,7 @@ mod tests {
                               mut event_target: ResMut<EventTarget>| {
             println!("Reading asset events this frame");
             for event in reader.read() {
-                println!("{:?}", event);
+                println!("{event:?}");
                 if matches!(
                     (event_target.event, event),
                     (AssetEvent::Added { .. }, AssetEvent::Added { .. })
diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs b/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs
@@ -50,7 +50,7 @@ impl Namespace {
     pub fn prefix(self) -> Cow<'static, str> {
         match self {
             Namespace::Global => Cow::Borrowed(""),
-            Namespace::OnType(type_id) => Cow::Owned(format!("{:?}::", type_id)),
+            Namespace::OnType(type_id) => Cow::Owned(format!("{type_id:?}::")),
         }
     }
 
diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs b/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs
@@ -463,7 +463,7 @@ impl ScriptFunctionRegistry {
                 if i == 0 {
                     self.get_function(namespace, name.clone())
                 } else {
-                    let name: Cow<'static, str> = format!("{}-{i}", name).into();
+                    let name: Cow<'static, str> = format!("{name}-{i}").into();
                     self.get_function(namespace, name)
                 }
             })
diff --git a/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs b/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs
@@ -90,7 +90,7 @@ impl ReflectReferencePrinter {
 
             if let Some(tail_type_id) = tail_type_id {
                 let type_path = tail_type_id.display_with_world(world);
-                pretty_path.push_str(&format!(" -> {}", type_path));
+                pretty_path.push_str(&format!(" -> {type_path}"));
             }
         } else {
             Self::pretty_print_base(&self.reference.base, None, &mut pretty_path);
@@ -111,7 +111,7 @@ impl ReflectReferencePrinter {
                         self.pretty_print_value_inner(r, &mut output);
                     })
                     .unwrap_or_else(|e| {
-                        output.push_str(&format!("<Error in printing: {}>", e));
+                        output.push_str(&format!("<Error in printing: {e}>"));
                     });
             }
             None => {
@@ -131,12 +131,12 @@ impl ReflectReferencePrinter {
         };
 
         let base_kind = match base.base_id {
-            ReflectBase::Component(e, _) => format!("Component on entity {}", e),
+            ReflectBase::Component(e, _) => format!("Component on entity {e}"),
             ReflectBase::Resource(_) => "Resource".to_owned(),
-            ReflectBase::Owned(ref id) => format!("Allocation({})", id),
+            ReflectBase::Owned(ref id) => format!("Allocation({id})"),
         };
 
-        out.push_str(&format!("{}({})", base_kind, type_path));
+        out.push_str(&format!("{base_kind}({type_path})"));
     }
 
     /// Pretty prints a value of an opaque type.
@@ -317,7 +317,7 @@ impl ReflectReferencePrinter {
             // for function_reflection from bevy or other feature gated things
             #[allow(unreachable_patterns)]
             _ => {
-                output.push_str(&format!("{:?}", v));
+                output.push_str(&format!("{v:?}"));
             }
         }
     }
@@ -414,7 +414,7 @@ impl DisplayWithWorld for ComponentId {
             .map(|info| info.name());
 
         match component_name {
-            Some(n) => format!("ComponentOrResource({})", n),
+            Some(n) => format!("ComponentOrResource({n})"),
             None => "ComponentOrResource(<Unknown>)".to_owned(),
         }
     }
@@ -450,14 +450,14 @@ impl DisplayWithWorld for ReflectAccessId {
                     if let Some(allocation) = allocator.get(&allocation_id) {
                         let ptr = allocation.get_ptr();
                         let val = unsafe { &*ptr };
-                        let o = format!("Allocation({:?})", val);
+                        let o = format!("Allocation({val:?})");
                         unsafe { world.release_access(raid) };
                         o
                     } else {
-                        format!("Allocation({})", allocation_id)
+                        format!("Allocation({allocation_id})")
                     }
                 } else {
-                    format!("Allocation({})", allocation_id)
+                    format!("Allocation({allocation_id})")
                 }
             }
             super::access_map::ReflectAccessKind::Global => "Global".to_owned(),
@@ -491,7 +491,7 @@ impl DisplayWithWorld for TypeId {
     }
 
     fn display_without_world(&self) -> String {
-        format!("{:?}", self)
+        format!("{self:?}")
     }
 }
 #[profiling::all_functions]
@@ -687,15 +687,15 @@ mod test {
         let type_id = TypeId::of::<usize>();
         assert_eq!(type_id.display_with_world(world.clone()), "usize");
         assert_eq!(type_id.display_value_with_world(world.clone()), "usize");
-        assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));
+        assert_eq!(type_id.display_without_world(), format!("{type_id:?}"));
 
         let type_id = TypeId::of::<FakeType>();
         assert_eq!(type_id.display_with_world(world.clone()), "Unknown Type");
         assert_eq!(
             type_id.display_value_with_world(world.clone()),
             "Unknown Type"
         );
-        assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));
+        assert_eq!(type_id.display_without_world(), format!("{type_id:?}"));
     }
 
     #[test]
@@ -729,7 +729,7 @@ mod test {
                 type_id,
             }
             .display_without_world(),
-            format!("Allocation(0)({:?})", type_id)
+            format!("Allocation(0)({type_id:?})")
         );
     }
 
@@ -763,7 +763,7 @@ mod test {
 
         assert_eq!(
             reflect_reference.display_without_world(),
-            format!("<Reference to Allocation({id})({:?})>", type_id)
+            format!("<Reference to Allocation({id})({type_id:?})>")
         );
     }
 
diff --git a/crates/bevy_mod_scripting_core/src/bindings/schedule.rs b/crates/bevy_mod_scripting_core/src/bindings/schedule.rs
@@ -307,7 +307,7 @@ mod tests {
                 if let Some(system) = graph.get_system_at(node_id) {
                     system.name().clone().to_string()
                 } else if let Some(system_set) = graph.get_set_at(node_id) {
-                    format!("{:?}", system_set).to_string()
+                    format!("{system_set:?}").to_string()
                 } else {
                     // try schedule systems
                     let mut default = format!("{node_id:?}").to_string();
@@ -352,10 +352,7 @@ mod tests {
         for &(exp_from, exp_to) in expected_edges {
             assert!(
                 found_edges.contains(&(exp_from.to_owned(), exp_to.to_owned())),
-                "Expected edge ({} -> {}) not found. Found edges: {:?}",
-                exp_from,
-                exp_to,
-                found_edges
+                "Expected edge ({exp_from} -> {exp_to}) not found. Found edges: {found_edges:?}"
             );
         }
 
diff --git a/crates/bevy_mod_scripting_core/src/bindings/script_system.rs b/crates/bevy_mod_scripting_core/src/bindings/script_system.rs
@@ -538,7 +538,7 @@ impl<P: IntoScriptPluginParams> System for DynamicScriptSystem<P> {
                         reason = "WIP, to be dealt with in validate params better, but panic will still remain"
                     )]
                     if subset.contains(&raid) {
-                        panic!("Duplicate resource access in system: {:?}.", raid);
+                        panic!("Duplicate resource access in system: {raid:?}.");
                     }
                     subset.insert(raid);
                 }
diff --git a/crates/bevy_mod_scripting_core/src/commands.rs b/crates/bevy_mod_scripting_core/src/commands.rs
@@ -445,7 +445,7 @@ mod test {
         .init_resource::<StaticScripts>()
         .insert_resource(CallbackSettings::<DummyPlugin> {
             callback_handler: |_, _, _, callback, c, _, _| {
-                c.push_str(format!(" callback-ran-{}", callback).as_str());
+                c.push_str(format!(" callback-ran-{callback}").as_str());
                 Ok(ScriptValue::Unit)
             },
         })
@@ -479,7 +479,7 @@ mod test {
         assert_eq!(id, script.id);
         let found_context = script.context.lock();
 
-        assert_eq!(*context, *found_context, "{}", message);
+        assert_eq!(*context, *found_context, "{message}");
     }
 
     fn assert_response_events(
@@ -495,13 +495,12 @@ mod test {
         assert_eq!(
             responses.len(),
             expected.len(),
-            "Incorrect amount of events received {}",
-            context
+            "Incorrect amount of events received {context}"
         );
         for (a, b) in responses.iter().zip(expected.iter()) {
-            assert_eq!(a.label, b.label, "{}", context);
-            assert_eq!(a.script, b.script, "{}", context);
-            assert_eq!(a.response, b.response, "{}", context);
+            assert_eq!(a.label, b.label, "{context}");
+            assert_eq!(a.script, b.script, "{context}");
+            assert_eq!(a.response, b.response, "{context}");
         }
     }
 
diff --git a/crates/bevy_mod_scripting_core/src/event.rs b/crates/bevy_mod_scripting_core/src/event.rs
@@ -301,7 +301,7 @@ mod test {
             '|', '\\', ':', ';', '"', '\'', '<', '>', ',', '.', '?', '/', '`', '~',
         ];
         bad_chars.iter().for_each(|char| {
-            assert_eq!(super::CallbackLabel::new(&format!("bad{}", char)), None);
+            assert_eq!(super::CallbackLabel::new(&format!("bad{char}")), None);
         });
     }
 
@@ -313,7 +313,7 @@ mod test {
             ',', '.', '?', '/', '`', '~',
         ];
         bad_chars.iter().for_each(|char| {
-            assert_eq!(super::CallbackLabel::new(&format!("{}bad", char)), None);
+            assert_eq!(super::CallbackLabel::new(&format!("{char}bad")), None);
         });
     }
 
diff --git a/crates/bevy_system_reflection/src/lib.rs b/crates/bevy_system_reflection/src/lib.rs
@@ -148,7 +148,7 @@ impl ReflectSystemSet {
     pub fn from_set(set: &dyn SystemSet, node_id: NodeId) -> Self {
         ReflectSystemSet {
             node_id: ReflectNodeId(node_id),
-            debug: format!("{:?}", set),
+            debug: format!("{set:?}"),
             type_id: set.system_type(),
         }
     }
diff --git a/crates/lad_backends/mdbook_lad_preprocessor/src/lib.rs b/crates/lad_backends/mdbook_lad_preprocessor/src/lib.rs
@@ -60,7 +60,7 @@ impl LADPreprocessor {
             .unwrap_or_default()
             .with_extension("");
 
-        log::debug!("Parent path: {:?}", parent_path);
+        log::debug!("Parent path: {parent_path:?}");
 
         let new_chapter = Section::new(
             parent_path,
@@ -91,7 +91,7 @@ impl Preprocessor for LADPreprocessor {
         let mut errors = Vec::new();
         let options = Options::from(context);
 
-        log::debug!("Options: {:?}", options);
+        log::debug!("Options: {options:?}");
         OPTIONS
             .set(options)
             .map_err(|_| mdbook::errors::Error::msg("could not initialize options"))?;
@@ -169,7 +169,7 @@ impl Preprocessor for LADPreprocessor {
         if !errors.is_empty() {
             // return on first error
             for error in errors {
-                log::error!("{}", error);
+                log::error!("{error}");
                 Err(error)?;
             }
         }
diff --git a/crates/lad_backends/mdbook_lad_preprocessor/src/markdown.rs b/crates/lad_backends/mdbook_lad_preprocessor/src/markdown.rs
@@ -34,7 +34,7 @@ pub(crate) fn markdown_substring(markdown: &str, length: usize) -> String {
 
     let trimmed = markdown[..end].to_string();
     // append ...
-    format!("{}...", trimmed)
+    format!("{trimmed}...")
 }
 
 /// Escapes Markdown reserved characters in the given text.
@@ -208,7 +208,7 @@ impl IntoMarkdown for Markdown {
             Markdown::CodeBlock { language, code } => {
                 // Do not escape code blocks
                 let lang = language.as_deref().unwrap_or("");
-                builder.append(&format!("```{}\n{}\n```", lang, code));
+                builder.append(&format!("```{lang}\n{code}\n```"));
             }
             Markdown::List { ordered, items } => {
                 items.iter().enumerate().for_each(|(i, item)| {
@@ -233,7 +233,7 @@ impl IntoMarkdown for Markdown {
             Markdown::Quote(text) => {
                 let quote_output = text
                     .lines()
-                    .map(|line| format!("> {}", line))
+                    .map(|line| format!("> {line}"))
                     .collect::<Vec<String>>()
                     .join("\n");
                 builder.append(&quote_output);
@@ -783,8 +783,7 @@ mod tests {
             assert_eq!(
                 expected,
                 markdown_substring(input, len),
-                "Failed for input: {}",
-                input
+                "Failed for input: {input}"
             );
         }
     }
diff --git a/crates/lad_backends/mdbook_lad_preprocessor/src/sections.rs b/crates/lad_backends/mdbook_lad_preprocessor/src/sections.rs
@@ -702,7 +702,7 @@ fn build_lad_function_argument_row(
         .name
         .as_ref()
         .cloned()
-        .unwrap_or_else(|| Cow::Owned(format!("arg{}", idx)));
+        .unwrap_or_else(|| Cow::Owned(format!("arg{idx}")));
 
     builder.row(markdown_vec![
         Markdown::new_paragraph(arg_name).bold(),
diff --git a/crates/lad_backends/mdbook_lad_preprocessor/tests/book_integration_tests.rs b/crates/lad_backends/mdbook_lad_preprocessor/tests/book_integration_tests.rs
@@ -83,8 +83,7 @@ fn test_on_example_ladfile() {
         let book_file = book_dir.join(relative_path);
         assert!(
             book_files.contains(&book_file),
-            "File not found: {:?}",
-            book_file
+            "File not found: {book_file:?}"
         );
         let expected_content =
             std::fs::read_to_string(&expected_file).expect("failed to read file");
diff --git a/crates/ladfile_builder/src/lib.rs b/crates/ladfile_builder/src/lib.rs
@@ -1107,7 +1107,7 @@ mod test {
                 .join("ladfile")
                 .join("test_assets");
 
-            println!("Blessing test file at {:?}", path_to_test_assets);
+            println!("Blessing test file at {path_to_test_assets:?}");
             std::fs::write(path_to_test_assets.join("test.lad.json"), &serialized).unwrap();
             panic!("Blessed test file, please rerun the test");
         }
diff --git a/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs b/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs
@@ -54,7 +54,7 @@ impl FromLua for LuaScriptValue {
             Value::String(s) => ScriptValue::String(s.to_str()?.to_owned().into()),
             Value::Function(f) => ScriptValue::Function(
                 (move |_context: FunctionCallContext, args: VecDeque<ScriptValue>| {
-                    println!("Lua function called with args: {:?}", args);
+                    println!("Lua function called with args: {args:?}");
                     match f.call::<LuaScriptValue>(
                         args.into_iter()
                             .map(LuaScriptValue)
diff --git a/crates/languages/bevy_mod_scripting_rhai/src/lib.rs b/crates/languages/bevy_mod_scripting_rhai/src/lib.rs
@@ -123,7 +123,7 @@ impl Default for RhaiScriptingPlugin {
                         for (key, function) in script_function_registry.iter_all() {
                             let name = key.name.clone();
                             if ReservedKeyword::is_reserved_keyword(&name) {
-                                let new_name = format!("{}_", name);
+                                let new_name = format!("{name}_");
                                 let mut new_function = function.clone();
                                 let new_info =
                                     function.info.deref().clone().with_name(new_name.clone());
diff --git a/crates/testing_crates/script_integration_test_harness/src/lib.rs b/crates/testing_crates/script_integration_test_harness/src/lib.rs
@@ -143,16 +143,16 @@ pub fn make_test_rhai_plugin() -> bevy_mod_scripting_rhai::RhaiScriptingPlugin {
         runtime.set_max_call_levels(1000);
         runtime.register_fn("assert", |a: Dynamic, b: &str| {
             if !a.is::<bool>() {
-                panic!("Expected a boolean value, but got {:?}", a);
+                panic!("Expected a boolean value, but got {a:?}");
             }
             if !a.as_bool().unwrap() {
-                panic!("Assertion failed. {}", b);
+                panic!("Assertion failed. {b}");
             }
         });
 
         runtime.register_fn("assert", |a: Dynamic| {
             if !a.is::<bool>() {
-                panic!("Expected a boolean value, but got {:?}", a);
+                panic!("Expected a boolean value, but got {a:?}");
             }
             if !a.as_bool().unwrap() {
                 panic!("Assertion failed");
diff --git a/crates/testing_crates/test_utils/src/lib.rs b/crates/testing_crates/test_utils/src/lib.rs
diff --git a/crates/xtask/src/main.rs b/crates/xtask/src/main.rs
diff --git a/rust-toolchain.toml b/rust-toolchain.toml

Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ fn script_benchmarks(criterion: &mut Criterion, filter: Option<Regex>) {`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`for (group, tests) in grouped {`
`112`		`- println!("Running benchmarks for group: {}", group);`
	`112`	`+ println!("Running benchmarks for group: {group}");`
`113`	`113`	`let mut benchmark_group = criterion.benchmark_group(group);`
`114`	`114`
`115`	`115`	`for t in tests {`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ impl Namespace {`
`50`	`50`	`pub fn prefix(self) -> Cow<'static, str> {`
`51`	`51`	`match self {`
`52`	`52`	`Namespace::Global => Cow::Borrowed(""),`
`53`		`- Namespace::OnType(type_id) => Cow::Owned(format!("{:?}::", type_id)),`
	`53`	`+ Namespace::OnType(type_id) => Cow::Owned(format!("{type_id:?}::")),`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
Original file line number	Diff line number	Diff line change
`@@ -463,7 +463,7 @@ impl ScriptFunctionRegistry {`
`463`	`463`	`if i == 0 {`
`464`	`464`	`self.get_function(namespace, name.clone())`
`465`	`465`	`} else {`
`466`		`- let name: Cow<'static, str> = format!("{}-{i}", name).into();`
	`466`	`+ let name: Cow<'static, str> = format!("{name}-{i}").into();`
`467`	`467`	`self.get_function(namespace, name)`
`468`	`468`	`}`
`469`	`469`	`})`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ impl ReflectReferencePrinter {`
`90`	`90`
`91`	`91`	`if let Some(tail_type_id) = tail_type_id {`
`92`	`92`	`let type_path = tail_type_id.display_with_world(world);`
`93`		`- pretty_path.push_str(&format!(" -> {}", type_path));`
	`93`	`+ pretty_path.push_str(&format!(" -> {type_path}"));`
`94`	`94`	`}`
`95`	`95`	`} else {`
`96`	`96`	`Self::pretty_print_base(&self.reference.base, None, &mut pretty_path);`
`@@ -111,7 +111,7 @@ impl ReflectReferencePrinter {`
`111`	`111`	`self.pretty_print_value_inner(r, &mut output);`
`112`	`112`	`})`
`113`	`113`	`.unwrap_or_else(\|e\| {`
`114`		`- output.push_str(&format!("<Error in printing: {}>", e));`
	`114`	`+ output.push_str(&format!("<Error in printing: {e}>"));`
`115`	`115`	`});`
`116`	`116`	`}`
`117`	`117`	`None => {`
`@@ -131,12 +131,12 @@ impl ReflectReferencePrinter {`
`131`	`131`	`};`
`132`	`132`
`133`	`133`	`let base_kind = match base.base_id {`
`134`		`- ReflectBase::Component(e, _) => format!("Component on entity {}", e),`
	`134`	`+ ReflectBase::Component(e, _) => format!("Component on entity {e}"),`
`135`	`135`	`ReflectBase::Resource(_) => "Resource".to_owned(),`
`136`		`- ReflectBase::Owned(ref id) => format!("Allocation({})", id),`
	`136`	`+ ReflectBase::Owned(ref id) => format!("Allocation({id})"),`
`137`	`137`	`};`
`138`	`138`
`139`		`- out.push_str(&format!("{}({})", base_kind, type_path));`
	`139`	`+ out.push_str(&format!("{base_kind}({type_path})"));`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`/// Pretty prints a value of an opaque type.`
`@@ -317,7 +317,7 @@ impl ReflectReferencePrinter {`
`317`	`317`	`// for function_reflection from bevy or other feature gated things`
`318`	`318`	`#[allow(unreachable_patterns)]`
`319`	`319`	`_ => {`
`320`		`- output.push_str(&format!("{:?}", v));`
	`320`	`+ output.push_str(&format!("{v:?}"));`
`321`	`321`	`}`
`322`	`322`	`}`
`323`	`323`	`}`
`@@ -414,7 +414,7 @@ impl DisplayWithWorld for ComponentId {`
`414`	`414`	`.map(\|info\| info.name());`
`415`	`415`
`416`	`416`	`match component_name {`
`417`		`- Some(n) => format!("ComponentOrResource({})", n),`
	`417`	`+ Some(n) => format!("ComponentOrResource({n})"),`
`418`	`418`	`None => "ComponentOrResource(<Unknown>)".to_owned(),`
`419`	`419`	`}`
`420`	`420`	`}`
`@@ -450,14 +450,14 @@ impl DisplayWithWorld for ReflectAccessId {`
`450`	`450`	`if let Some(allocation) = allocator.get(&allocation_id) {`
`451`	`451`	`let ptr = allocation.get_ptr();`
`452`	`452`	`let val = unsafe { &*ptr };`
`453`		`- let o = format!("Allocation({:?})", val);`
	`453`	`+ let o = format!("Allocation({val:?})");`
`454`	`454`	`unsafe { world.release_access(raid) };`
`455`	`455`	`o`
`456`	`456`	`} else {`
`457`		`- format!("Allocation({})", allocation_id)`
	`457`	`+ format!("Allocation({allocation_id})")`
`458`	`458`	`}`
`459`	`459`	`} else {`
`460`		`- format!("Allocation({})", allocation_id)`
	`460`	`+ format!("Allocation({allocation_id})")`
`461`	`461`	`}`
`462`	`462`	`}`
`463`	`463`	`super::access_map::ReflectAccessKind::Global => "Global".to_owned(),`
`@@ -491,7 +491,7 @@ impl DisplayWithWorld for TypeId {`
`491`	`491`	`}`
`492`	`492`
`493`	`493`	`fn display_without_world(&self) -> String {`
`494`		`- format!("{:?}", self)`
	`494`	`+ format!("{self:?}")`
`495`	`495`	`}`
`496`	`496`	`}`
`497`	`497`	`#[profiling::all_functions]`
`@@ -687,15 +687,15 @@ mod test {`
`687`	`687`	`let type_id = TypeId::of::<usize>();`
`688`	`688`	`assert_eq!(type_id.display_with_world(world.clone()), "usize");`
`689`	`689`	`assert_eq!(type_id.display_value_with_world(world.clone()), "usize");`
`690`		`- assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));`
	`690`	`+ assert_eq!(type_id.display_without_world(), format!("{type_id:?}"));`
`691`	`691`
`692`	`692`	`let type_id = TypeId::of::<FakeType>();`
`693`	`693`	`assert_eq!(type_id.display_with_world(world.clone()), "Unknown Type");`
`694`	`694`	`assert_eq!(`
`695`	`695`	`type_id.display_value_with_world(world.clone()),`
`696`	`696`	`"Unknown Type"`
`697`	`697`	`);`
`698`		`- assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));`
	`698`	`+ assert_eq!(type_id.display_without_world(), format!("{type_id:?}"));`
`699`	`699`	`}`
`700`	`700`
`701`	`701`	`#[test]`
`@@ -729,7 +729,7 @@ mod test {`
`729`	`729`	`type_id,`
`730`	`730`	`}`
`731`	`731`	`.display_without_world(),`
`732`		`- format!("Allocation(0)({:?})", type_id)`
	`732`	`+ format!("Allocation(0)({type_id:?})")`
`733`	`733`	`);`
`734`	`734`	`}`
`735`	`735`
`@@ -763,7 +763,7 @@ mod test {`
`763`	`763`
`764`	`764`	`assert_eq!(`
`765`	`765`	`reflect_reference.display_without_world(),`
`766`		`- format!("<Reference to Allocation({id})({:?})>", type_id)`
	`766`	`+ format!("<Reference to Allocation({id})({type_id:?})>")`
`767`	`767`	`);`
`768`	`768`	`}`
`769`	`769`
Original file line number	Diff line number	Diff line change
`@@ -538,7 +538,7 @@ impl<P: IntoScriptPluginParams> System for DynamicScriptSystem<P> {`
`538`	`538`	`reason = "WIP, to be dealt with in validate params better, but panic will still remain"`
`539`	`539`	`)]`
`540`	`540`	`if subset.contains(&raid) {`
`541`		`- panic!("Duplicate resource access in system: {:?}.", raid);`
	`541`	`+ panic!("Duplicate resource access in system: {raid:?}.");`
`542`	`542`	`}`
`543`	`543`	`subset.insert(raid);`
`544`	`544`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ impl ReflectSystemSet {`
`148`	`148`	`pub fn from_set(set: &dyn SystemSet, node_id: NodeId) -> Self {`
`149`	`149`	`ReflectSystemSet {`
`150`	`150`	`node_id: ReflectNodeId(node_id),`
`151`		`- debug: format!("{:?}", set),`
	`151`	`+ debug: format!("{set:?}"),`
`152`	`152`	`type_id: set.system_type(),`
`153`	`153`	`}`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1107,7 +1107,7 @@ mod test {`
`1107`	`1107`	`.join("ladfile")`
`1108`	`1108`	`.join("test_assets");`
`1109`	`1109`
`1110`		`- println!("Blessing test file at {:?}", path_to_test_assets);`
	`1110`	`+ println!("Blessing test file at {path_to_test_assets:?}");`
`1111`	`1111`	`std::fs::write(path_to_test_assets.join("test.lad.json"), &serialized).unwrap();`
`1112`	`1112`	`panic!("Blessed test file, please rerun the test");`
`1113`	`1113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,16 +143,16 @@ pub fn make_test_rhai_plugin() -> bevy_mod_scripting_rhai::RhaiScriptingPlugin {`
`143`	`143`	`runtime.set_max_call_levels(1000);`
`144`	`144`	`runtime.register_fn("assert", \|a: Dynamic, b: &str\| {`
`145`	`145`	`if !a.is::<bool>() {`
`146`		`- panic!("Expected a boolean value, but got {:?}", a);`
	`146`	`+ panic!("Expected a boolean value, but got {a:?}");`
`147`	`147`	`}`
`148`	`148`	`if !a.as_bool().unwrap() {`
`149`		`- panic!("Assertion failed. {}", b);`
	`149`	`+ panic!("Assertion failed. {b}");`
`150`	`150`	`}`
`151`	`151`	`});`
`152`	`152`
`153`	`153`	`runtime.register_fn("assert", \|a: Dynamic\| {`
`154`	`154`	`if !a.is::<bool>() {`
`155`		`- panic!("Expected a boolean value, but got {:?}", a);`
	`155`	`+ panic!("Expected a boolean value, but got {a:?}");`
`156`	`156`	`}`
`157`	`157`	`if !a.as_bool().unwrap() {`
`158`	`158`	`panic!("Assertion failed");`