Use new format macro syntax

Author: chitoyuu

bindings-generator/src/api.rs

@@ -785,7 +785,7 @@ mod tests {
         ];
         tests.iter().for_each(|(class_name, expected)| {
             let actual = module_name_from_class_name(class_name);
-            assert_eq!(*expected, actual, "Input: {}", class_name);
+            assert_eq!(*expected, actual, "Input: {class_name}");
         });
     }
 }

bindings-generator/src/class_docs.rs

@@ -67,20 +67,10 @@ impl GodotXmlDocs {
                         if let Some(property_name) = node.attribute("name") {
                             if !property_name.contains('/') {
                                 if node.has_attribute("setter") {
-                                    self.add_fn(
-                                        class,
-                                        &format!("set_{}", property_name),
-                                        desc,
-                                        &[],
-                                    );
+                                    self.add_fn(class, &format!("set_{property_name}"), desc, &[]);
                                 }
                                 if node.has_attribute("getter") {
-                                    self.add_fn(
-                                        class,
-                                        &format!("get_{}", property_name),
-                                        desc,
-                                        &[],
-                                    );
+                                    self.add_fn(class, &format!("get_{property_name}"), desc, &[]);
                                 }
                             }
                         }
@@ -187,10 +177,7 @@ impl GodotXmlDocs {
 
         // Info for GDScript blocks
         let godot_doc = if godot_doc.contains("[codeblock]") {
-            format!(
-                "_Sample code is GDScript unless otherwise noted._\n\n{}",
-                godot_doc
-            )
+            format!("_Sample code is GDScript unless otherwise noted._\n\n{godot_doc}")
         } else {
             godot_doc
         };
@@ -213,9 +200,9 @@ impl GodotXmlDocs {
             let text = &c[2];
 
             if text.is_empty() {
-                format!("<{url}>", url = url)
+                format!("<{url}>")
             } else {
-                format!("[{text}]({url})", text = text, url = url)
+                format!("[{text}]({url})")
             }
         });
 
@@ -247,11 +234,7 @@ impl GodotXmlDocs {
             let godot_ty = &c[2];
             let rust_ty = Self::translate_type(godot_ty);
 
-            format!(
-                "[`{godot_ty}`][{rust_ty}]",
-                godot_ty = godot_ty,
-                rust_ty = rust_ty
-            )
+            format!("[`{godot_ty}`][{rust_ty}]")
         });
 
         godot_doc.to_string()

bindings-generator/src/documentation.rs

@@ -149,7 +149,7 @@ fn list_base_classes(output: &mut impl Write, api: &Api, parent_name: &str) -> G
     if let Some(parent) = api.find_class(parent_name) {
         let class_link = class_doc_link(parent);
 
-        writeln!(output, " - {}", class_link)?;
+        writeln!(output, " - {class_link}")?;
 
         if !parent.base_class.is_empty() {
             list_base_classes(output, api, &parent.base_class)?;

bindings-generator/src/godot_version.rs

@@ -15,12 +15,7 @@ pub fn parse_godot_version(version_str: &str) -> Result<GodotVersion, Box<dyn Er
 
     let caps = regex.captures(version_str).ok_or("Regex capture failed")?;
 
-    let fail = || {
-        format!(
-            "Version substring could not be matched in '{}'",
-            version_str
-        )
-    };
+    let fail = || format!("Version substring could not be matched in '{version_str}'");
 
     Ok(GodotVersion {
         major: caps.get(1).ok_or_else(fail)?.as_str().parse::<u8>()?,

bindings-generator/src/methods.rs

@@ -200,7 +200,7 @@ pub fn generate_method_table(api: &Api, class: &GodotClass) -> TokenStream {
         } = m.get_name();
 
         let rust_ident = format_ident!("{}", rust_name);
-        let original_name = format!("{}\0", original_name);
+        let original_name = format!("{original_name}\0");
 
         if !skip_method(m, rust_name) {
             assert!(original_name.ends_with('\0'), "original_name must be null terminated");

bindings-generator/src/special_methods.rs

@@ -113,7 +113,7 @@ pub fn generate_singleton_getter(class: &GodotClass) -> TokenStream {
         class.name.as_ref()
     };
 
-    let singleton_name = format!("{}\0", s_name);
+    let singleton_name = format!("{s_name}\0");
 
     assert!(
         singleton_name.ends_with('\0'),

gdnative-async/src/method.rs

@@ -209,7 +209,7 @@ impl<C: NativeClass, F: AsyncMethod<C>> Method<C> for Async<F> {
                 Some(Err(err)) => {
                     log::error(
                         Self::site().unwrap_or_default(),
-                        format_args!("unable to spawn future: {}", err),
+                        format_args!("unable to spawn future: {err}"),
                     );
                     Variant::nil()
                 }

gdnative-async/src/rt.rs

@@ -107,8 +107,8 @@ pub fn register_runtime_with_prefix<S>(handle: &InitHandle, prefix: S)
 where
     S: Display,
 {
-    handle.add_class_as::<bridge::SignalBridge>(format!("{}SignalBridge", prefix));
-    handle.add_class_as::<func_state::FuncState>(format!("{}FuncState", prefix));
+    handle.add_class_as::<bridge::SignalBridge>(format!("{prefix}SignalBridge"));
+    handle.add_class_as::<func_state::FuncState>(format!("{prefix}FuncState"));
 }
 
 /// Releases all observers still in use. This should be called in the

gdnative-bindings/build.rs

@@ -92,16 +92,15 @@ fn generate(
     for (class, code) in &binding_res.class_bindings {
         let mod_name = gen::module_name_from_class_name(&class.name);
 
-        let mod_path = out_path.join(format!("{}.rs", mod_name));
+        let mod_path = out_path.join(format!("{mod_name}.rs"));
         let mut mod_output = BufWriter::new(File::create(&mod_path).unwrap());
 
         write!(
             &mut mod_output,
             r#"
-            {content}
+            {code}
             use super::*;
             "#,
-            content = code,
         )
         .unwrap();
 
@@ -152,7 +151,7 @@ fn format_file_if_needed(output_rs: &Path) {
         Ok(_) => println!("Done."),
         Err(err) => {
             println!("Failed.");
-            println!("Error: {}", err);
+            println!("Error: {err}");
         }
     }
 }

gdnative-core/src/core_types/byte_array.rs

@@ -49,6 +49,6 @@ godot_test!(
 godot_test!(
     test_byte_array_debug {
         let arr = (0..8).collect::<ByteArray>();
-        assert_eq!(format!("{:?}", arr), "[0, 1, 2, 3, 4, 5, 6, 7]");
+        assert_eq!(format!("{arr:?}"), "[0, 1, 2, 3, 4, 5, 6, 7]");
     }
 );