cargo clippy --fix

Author: encounter

src/analysis/cfa.rs

@@ -191,7 +191,7 @@ impl AnalyzerState {
             };
             obj.add_symbol(
                 ObjSymbol {
-                    name: format!("jumptable_{}", address_str),
+                    name: format!("jumptable_{address_str}"),
                     address: addr.address as u64,
                     section: Some(addr.section),
                     size: size as u64,
@@ -275,7 +275,7 @@ impl AnalyzerState {
             let (section_index, _) = obj
                 .sections
                 .at_address(entry)
-                .context(format!("Entry point {:#010X} outside of any section", entry))?;
+                .context(format!("Entry point {entry:#010X} outside of any section"))?;
             self.process_function_at(obj, SectionAddress::new(section_index, entry))?;
         }
         // Locate bounds for referenced functions until none are left
@@ -530,7 +530,7 @@ pub fn locate_sda_bases(obj: &mut ObjInfo) -> Result<bool> {
     let (section_index, _) = obj
         .sections
         .at_address(entry as u32)
-        .context(format!("Entry point {:#010X} outside of any section", entry))?;
+        .context(format!("Entry point {entry:#010X} outside of any section"))?;
     let entry_addr = SectionAddress::new(section_index, entry as u32);
 
     let mut executor = Executor::new(obj);
@@ -589,7 +589,7 @@ pub fn locate_bss_memsets(obj: &mut ObjInfo) -> Result<Vec<(u32, u32)>> {
     let (section_index, _) = obj
         .sections
         .at_address(entry as u32)
-        .context(format!("Entry point {:#010X} outside of any section", entry))?;
+        .context(format!("Entry point {entry:#010X} outside of any section"))?;
     let entry_addr = SectionAddress::new(section_index, entry as u32);
 
     let mut executor = Executor::new(obj);

src/analysis/mod.rs

@@ -183,8 +183,7 @@ fn get_jump_table_entries(
                     let (section_index, _) =
                         obj.sections.at_address(entry_addr).with_context(|| {
                             format!(
-                                "Invalid jump table entry {:#010X} at {:#010X}",
-                                entry_addr, cur_addr
+                                "Invalid jump table entry {entry_addr:#010X} at {cur_addr:#010X}"
                             )
                         })?;
                     entries.push(SectionAddress::new(section_index, entry_addr));

src/analysis/pass.rs

@@ -101,7 +101,7 @@ impl AnalysisPass for FindSaveRestSleds {
                 for i in reg_start..reg_end {
                     let addr = start + (i - reg_start) * step_size;
                     state.known_symbols.entry(addr).or_default().push(ObjSymbol {
-                        name: format!("{}{}", label, i),
+                        name: format!("{label}{i}"),
                         address: addr.address as u64,
                         section: Some(start.section),
                         size_known: true,

src/analysis/slices.rs

@@ -227,7 +227,7 @@ impl FunctionSlices {
             })?;
         }
         self.check_epilogue(section, ins_addr, ins)
-            .with_context(|| format!("While processing {:#010X}: {:#?}", function_start, self))?;
+            .with_context(|| format!("While processing {function_start:#010X}: {self:#?}"))?;
         if !self.has_conditional_blr && is_conditional_blr(ins) {
             self.has_conditional_blr = true;
         }

src/analysis/tracker.rs

@@ -576,7 +576,7 @@ impl Tracker {
             let relocation_target = relocation_target_for(obj, from, None).ok().flatten();
             if !matches!(relocation_target, None | Some(RelocationTarget::External)) {
                 // VM should have already handled this
-                panic!("Relocation already exists for {:#010X} (from {:#010X})", addr, from);
+                panic!("Relocation already exists for {addr:#010X} (from {from:#010X})");
             }
         }
         // Remainder of this function is for executable objects only
@@ -668,7 +668,7 @@ impl Tracker {
                 0
             };
             let new_name =
-                if module_id == 0 { name.to_string() } else { format!("{}:{}", name, module_id) };
+                if module_id == 0 { name.to_string() } else { format!("{name}:{module_id}") };
             log::debug!("Renaming {} to {}", section.name, new_name);
             section.name = new_name;
         }

src/cmd/ar.rs

@@ -127,16 +127,16 @@ fn extract(args: ExtractArgs) -> Result<()> {
         }
         std::fs::create_dir_all(&out_dir)?;
         if !args.quiet {
-            println!("Extracting {} to {}", path, out_dir);
+            println!("Extracting {path} to {out_dir}");
         }
 
         let mut file = open_file(path, false)?;
         let mut archive = ar::Archive::new(file.map()?);
         while let Some(entry) = archive.next_entry() {
-            let mut entry = entry.with_context(|| format!("Processing entry in {}", path))?;
+            let mut entry = entry.with_context(|| format!("Processing entry in {path}"))?;
             let file_name = std::str::from_utf8(entry.header().identifier())?;
             if !args.quiet && args.verbose {
-                println!("\t{}", file_name);
+                println!("\t{file_name}");
             }
             let mut file_path = out_dir.clone();
             for segment in file_name.split(&['/', '\\']) {
@@ -146,15 +146,15 @@ fn extract(args: ExtractArgs) -> Result<()> {
                 std::fs::create_dir_all(parent)?;
             }
             let mut file = File::create(&file_path)
-                .with_context(|| format!("Failed to create file {}", file_path))?;
+                .with_context(|| format!("Failed to create file {file_path}"))?;
             std::io::copy(&mut entry, &mut file)?;
             file.flush()?;
 
             num_files += 1;
         }
     }
     if !args.quiet {
-        println!("Extracted {} files", num_files);
+        println!("Extracted {num_files} files");
     }
     Ok(())
 }

src/cmd/dol.rs

@@ -536,7 +536,7 @@ pub fn info(args: InfoArgs) -> Result<()> {
 
     println!("{}:", obj.name);
     if let Some(entry) = obj.entry {
-        println!("Entry point: {:#010X}", entry);
+        println!("Entry point: {entry:#010X}");
     }
     println!("\nSections:");
     println!("\t{: >10} | {: <10} | {: <10} | {: <10}", "Name", "Address", "Size", "File Off");
@@ -955,7 +955,7 @@ fn split_write_obj(
     DirBuilder::new()
         .recursive(true)
         .create(out_dir)
-        .with_context(|| format!("Failed to create out dir '{}'", out_dir))?;
+        .with_context(|| format!("Failed to create out dir '{out_dir}'"))?;
     let obj_dir = out_dir.join("obj");
     let entry = if module.obj.kind == ObjKind::Executable {
         module.obj.entry.and_then(|e| {
@@ -1056,9 +1056,8 @@ fn split_write_obj(
     // Generate ldscript.lcf
     let ldscript_template = if let Some(template_path) = &module.config.ldscript_template {
         let template_path = template_path.with_encoding();
-        let template = fs::read_to_string(&template_path).with_context(|| {
-            format!("Failed to read linker script template '{}'", template_path)
-        })?;
+        let template = fs::read_to_string(&template_path)
+            .with_context(|| format!("Failed to read linker script template '{template_path}'"))?;
         module.dep.push(template_path);
         Some(template)
     } else {
@@ -1076,8 +1075,7 @@ fn split_write_obj(
             let out_path = asm_dir.join(asm_path_for_unit(&unit.name));
 
             let mut w = buf_writer(&out_path)?;
-            write_asm(&mut w, split_obj)
-                .with_context(|| format!("Failed to write {}", out_path))?;
+            write_asm(&mut w, split_obj).with_context(|| format!("Failed to write {out_path}"))?;
             w.flush()?;
         }
     }
@@ -1094,7 +1092,7 @@ fn write_if_changed(path: &Utf8NativePath, contents: &[u8]) -> Result<()> {
             return Ok(());
         }
     }
-    fs::write(path, contents).with_context(|| format!("Failed to write file '{}'", path))?;
+    fs::write(path, contents).with_context(|| format!("Failed to write file '{path}'"))?;
     Ok(())
 }
 
@@ -2166,7 +2164,7 @@ impl ObjectBase {
                 }
                 base.join(path.with_encoding())
             }
-            ObjectBase::Vfs(base, _) => Utf8NativePathBuf::from(format!("{}:{}", base, path)),
+            ObjectBase::Vfs(base, _) => Utf8NativePathBuf::from(format!("{base}:{path}")),
         }
     }
 
@@ -2183,7 +2181,7 @@ impl ObjectBase {
             }
             ObjectBase::Vfs(vfs_path, vfs) => {
                 open_file_with_fs(vfs.clone(), &path.with_encoding(), true)
-                    .with_context(|| format!("Using disc image {}", vfs_path))
+                    .with_context(|| format!("Using disc image {vfs_path}"))
             }
         }
     }
@@ -2201,26 +2199,26 @@ pub fn find_object_base(config: &ProjectConfig) -> Result<ObjectBase> {
     if let Some(base) = &config.object_base {
         let base = base.with_encoding();
         // Search for disc images in the object base directory
-        for result in fs::read_dir(&base).with_context(|| format!("Reading directory {}", base))? {
-            let entry = result.with_context(|| format!("Reading entry in directory {}", base))?;
+        for result in fs::read_dir(&base).with_context(|| format!("Reading directory {base}"))? {
+            let entry = result.with_context(|| format!("Reading entry in directory {base}"))?;
             let Ok(path) = check_path_buf(entry.path()) else {
                 log::warn!("Path is not valid UTF-8: {:?}", entry.path());
                 continue;
             };
             let file_type =
-                entry.file_type().with_context(|| format!("Getting file type for {}", path))?;
+                entry.file_type().with_context(|| format!("Getting file type for {path}"))?;
             let is_file = if file_type.is_symlink() {
                 // Also traverse symlinks to files
                 fs::metadata(&path)
-                    .with_context(|| format!("Getting metadata for {}", path))?
+                    .with_context(|| format!("Getting metadata for {path}"))?
                     .is_file()
             } else {
                 file_type.is_file()
             };
             if is_file {
                 let mut file = open_file(&path, false)?;
                 let format = detect(file.as_mut())
-                    .with_context(|| format!("Detecting file type for {}", path))?;
+                    .with_context(|| format!("Detecting file type for {path}"))?;
                 match format {
                     FileFormat::Archive(ArchiveKind::Disc(format)) => {
                         let fs = open_fs(file, ArchiveKind::Disc(format))?;
@@ -2249,23 +2247,23 @@ fn extract_objects(config: &ProjectConfig, object_base: &ObjectBase) -> Result<U
     {
         let target_path = extracted_path(&target_dir, &config.base.object);
         if !fs::exists(&target_path)
-            .with_context(|| format!("Failed to check path '{}'", target_path))?
+            .with_context(|| format!("Failed to check path '{target_path}'"))?
         {
             object_paths.push((&config.base.object, config.base.hash.as_deref(), target_path));
         }
     }
     if let Some(selfile) = &config.selfile {
         let target_path = extracted_path(&target_dir, selfile);
         if !fs::exists(&target_path)
-            .with_context(|| format!("Failed to check path '{}'", target_path))?
+            .with_context(|| format!("Failed to check path '{target_path}'"))?
         {
             object_paths.push((selfile, config.selfile_hash.as_deref(), target_path));
         }
     }
     for module_config in &config.modules {
         let target_path = extracted_path(&target_dir, &module_config.object);
         if !fs::exists(&target_path)
-            .with_context(|| format!("Failed to check path '{}'", target_path))?
+            .with_context(|| format!("Failed to check path '{target_path}'"))?
         {
             object_paths.push((&module_config.object, module_config.hash.as_deref(), target_path));
         }
@@ -2284,12 +2282,12 @@ fn extract_objects(config: &ProjectConfig, object_base: &ObjectBase) -> Result<U
         let mut file = object_base.open(source_path)?;
         if let Some(parent) = target_path.parent() {
             fs::create_dir_all(parent)
-                .with_context(|| format!("Failed to create directory '{}'", parent))?;
+                .with_context(|| format!("Failed to create directory '{parent}'"))?;
         }
         let mut out = fs::File::create(&target_path)
-            .with_context(|| format!("Failed to create file '{}'", target_path))?;
+            .with_context(|| format!("Failed to create file '{target_path}'"))?;
         let hash_bytes = buf_copy_with_hash(&mut file, &mut out)
-            .with_context(|| format!("Failed to extract file '{}'", target_path))?;
+            .with_context(|| format!("Failed to extract file '{target_path}'"))?;
         if let Some(hash) = hash {
             check_hash_str(hash_bytes, hash).with_context(|| {
                 format!("Source file failed verification: '{}'", object_base.join(source_path))

src/cmd/dwarf.rs

@@ -104,16 +104,16 @@ fn dump(args: DumpArgs) -> Result<()> {
                 // TODO make a basename method
                 let name = name.trim_start_matches("D:").replace('\\', "/");
                 let name = name.rsplit_once('/').map(|(_, b)| b).unwrap_or(&name);
-                let file_path = out_path.join(format!("{}.txt", name));
+                let file_path = out_path.join(format!("{name}.txt"));
                 let mut file = buf_writer(&file_path)?;
                 dump_debug_section(&args, &mut file, &obj_file, debug_section)?;
                 file.flush()?;
             } else if args.no_color {
-                println!("\n// File {}:", name);
+                println!("\n// File {name}:");
                 dump_debug_section(&args, &mut stdout(), &obj_file, debug_section)?;
             } else {
                 let mut writer = HighlightWriter::new(syntax_set.clone(), syntax.clone(), theme);
-                writeln!(writer, "\n// File {}:", name)?;
+                writeln!(writer, "\n// File {name}:")?;
                 dump_debug_section(&args, &mut writer, &obj_file, debug_section)?;
             }
         }
@@ -209,26 +209,25 @@ where
                     }
                     writeln!(w, "\n/*\n    Compile unit: {}", unit.name)?;
                     if let Some(producer) = unit.producer {
-                        writeln!(w, "    Producer: {}", producer)?;
+                        writeln!(w, "    Producer: {producer}")?;
                     }
                     if let Some(comp_dir) = unit.comp_dir {
-                        writeln!(w, "    Compile directory: {}", comp_dir)?;
+                        writeln!(w, "    Compile directory: {comp_dir}")?;
                     }
                     if let Some(language) = unit.language {
-                        writeln!(w, "    Language: {}", language)?;
+                        writeln!(w, "    Language: {language}")?;
                     }
                     if let (Some(start), Some(end)) = (unit.start_address, unit.end_address) {
-                        writeln!(w, "    Code range: {:#010X} -> {:#010X}", start, end)?;
+                        writeln!(w, "    Code range: {start:#010X} -> {end:#010X}")?;
                     }
                     if let Some(gcc_srcfile_name_offset) = unit.gcc_srcfile_name_offset {
                         writeln!(
                             w,
-                            "    GCC Source File Name Offset: {:#010X}",
-                            gcc_srcfile_name_offset
+                            "    GCC Source File Name Offset: {gcc_srcfile_name_offset:#010X}"
                         )?;
                     }
                     if let Some(gcc_srcinfo_offset) = unit.gcc_srcinfo_offset {
-                        writeln!(w, "    GCC Source Info Offset: {:#010X}", gcc_srcinfo_offset)?;
+                        writeln!(w, "    GCC Source Info Offset: {gcc_srcinfo_offset:#010X}")?;
                     }
                     writeln!(w, "*/")?;
 
@@ -269,7 +268,7 @@ where
                             continue;
                         }
                         match tag_type_string(&info, &typedefs, &tag_type, child.is_erased) {
-                            Ok(s) => writeln!(w, "{}", s)?,
+                            Ok(s) => writeln!(w, "{s}")?,
                             Err(e) => {
                                 log::error!(
                                     "Failed to emit tag {:X} (unit {}): {}",

src/cmd/elf.rs

@@ -146,14 +146,14 @@ fn disasm(args: DisasmArgs) -> Result<()> {
             let mut files_out = buf_writer(&args.out.join("link_order.txt"))?;
             for (unit, split_obj) in obj.link_order.iter().zip(&split_objs) {
                 let out_name = file_stem_from_unit(&unit.name);
-                let out_path = asm_dir.join(format!("{}.s", out_name));
+                let out_path = asm_dir.join(format!("{out_name}.s"));
                 log::info!("Writing {}", out_path);
 
                 let mut w = buf_writer(&out_path)?;
                 write_asm(&mut w, split_obj)?;
                 w.flush()?;
 
-                writeln!(files_out, "{}.o", out_name)?;
+                writeln!(files_out, "{out_name}.o")?;
             }
             files_out.flush()?;
         }
@@ -402,7 +402,7 @@ fn signatures(args: SignaturesArgs) -> Result<()> {
             Ok(Some(signature)) => signature,
             Ok(None) => continue,
             Err(e) => {
-                eprintln!("Failed: {:?}", e);
+                eprintln!("Failed: {e:?}");
                 continue;
             }
         };
@@ -545,13 +545,13 @@ fn info(args: InfoArgs) -> Result<()> {
                     .context("While reading .note.split section")?;
             println!("\nSplit metadata (.note.split):");
             if let Some(generator) = &meta.generator {
-                println!("\tGenerator: {}", generator);
+                println!("\tGenerator: {generator}");
             }
             if let Some(module_name) = &meta.module_name {
-                println!("\tModule name: {}", module_name);
+                println!("\tModule name: {module_name}");
             }
             if let Some(module_id) = meta.module_id {
-                println!("\tModule ID: {}", module_id);
+                println!("\tModule ID: {module_id}");
             }
             if let Some(virtual_addresses) = &meta.virtual_addresses {
                 println!("\tVirtual addresses:");

src/cmd/map.rs

@@ -175,7 +175,7 @@ fn symbol(args: SymbolArgs) -> Result<()> {
     if let Some(vec) = entries.unit_references.get_vec(&symbol_ref) {
         println!("\nGenerated in TUs:");
         for x in vec {
-            println!(">>> {}", x);
+            println!(">>> {x}");
         }
     }
     println!("\n");