cc: replace manual Default impls with #[derive(Default)]

Replace boilerplate new()/impl Default with #[derive(Default)] for
Module, Pseudo, PseudoId, PseudoKind, TranslationUnit, SymbolInfo,
and CrossRef. Use .or_default() instead of .or_insert_with(T::new).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jgarzik

cc/arch/mapping.rs

@@ -1838,7 +1838,7 @@ mod tests {
     fn test_run_mapping_empty() {
         let target = Target::new(Arch::X86_64, Os::Linux);
         let types = TypeTable::new(&target);
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         run_mapping(&mut module, &types, &target);
     }
@@ -1848,7 +1848,7 @@ mod tests {
         let target = Target::new(Arch::X86_64, Os::Linux);
         let types = TypeTable::new(&target);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(make_test_func(&types));
         module.add_function(make_test_func(&types));
 
@@ -1860,7 +1860,7 @@ mod tests {
         let target = Target::new(Arch::X86_64, Os::Linux);
         let types = TypeTable::new(&target);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(make_test_func(&types));
 
         run_mapping(&mut module, &types, &target);
@@ -1879,7 +1879,7 @@ mod tests {
 
         for target in &targets {
             let types = TypeTable::new(target);
-            let mut module = Module::new();
+            let mut module = Module::default();
             module.add_function(make_test_func(&types));
             run_mapping(&mut module, &types, target);
         }
@@ -1890,7 +1890,7 @@ mod tests {
         let target = Target::new(Arch::X86_64, Os::Linux);
         let types = TypeTable::new(&target);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(make_test_func(&types));
         let orig_insn_count = module.functions[0].blocks[0].insns.len();
 
@@ -1905,7 +1905,7 @@ mod tests {
         let target = Target::new(Arch::Aarch64, Os::Linux);
         let types = TypeTable::new(&target);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(make_test_func(&types));
         let orig_insn_count = module.functions[0].blocks[0].insns.len();
 
@@ -1943,7 +1943,7 @@ mod tests {
         func.add_block(bb);
         func.entry = BasicBlockId(0);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(func);
         run_mapping(&mut module, &types, &target);
 
@@ -1984,7 +1984,7 @@ mod tests {
         func.add_block(bb);
         func.entry = BasicBlockId(0);
 
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.add_function(func);
         run_mapping(&mut module, &types, &target);
 

cc/cxref.rs

@@ -77,20 +77,14 @@ struct SymbolRef {
 }
 
 /// Information about a symbol across files
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 struct SymbolInfo {
     /// References organized by file, then by function scope
     /// Map: file -> Map: function (or empty for global) -> refs
     refs: BTreeMap<String, BTreeMap<String, BTreeSet<SymbolRef>>>,
 }
 
 impl SymbolInfo {
-    fn new() -> Self {
-        Self {
-            refs: BTreeMap::new(),
-        }
-    }
-
     fn add_ref(&mut self, file: &str, function: &str, line: u32, is_definition: bool) {
         self.refs
             .entry(file.to_string())
@@ -105,6 +99,7 @@ impl SymbolInfo {
 }
 
 /// Cross-reference table
+#[derive(Default)]
 struct CrossRef {
     /// All symbols: name -> info
     symbols: BTreeMap<String, SymbolInfo>,
@@ -115,14 +110,6 @@ struct CrossRef {
 }
 
 impl CrossRef {
-    fn new() -> Self {
-        Self {
-            symbols: BTreeMap::new(),
-            current_file: String::new(),
-            current_function: String::new(),
-        }
-    }
-
     fn set_file(&mut self, file: &str) {
         self.current_file = file.to_string();
     }
@@ -132,17 +119,21 @@ impl CrossRef {
     }
 
     fn add_definition(&mut self, name: &str, line: u32) {
-        self.symbols
-            .entry(name.to_string())
-            .or_insert_with(SymbolInfo::new)
-            .add_ref(&self.current_file, &self.current_function, line, true);
+        self.symbols.entry(name.to_string()).or_default().add_ref(
+            &self.current_file,
+            &self.current_function,
+            line,
+            true,
+        );
     }
 
     fn add_reference(&mut self, name: &str, line: u32) {
-        self.symbols
-            .entry(name.to_string())
-            .or_insert_with(SymbolInfo::new)
-            .add_ref(&self.current_file, &self.current_function, line, false);
+        self.symbols.entry(name.to_string()).or_default().add_ref(
+            &self.current_file,
+            &self.current_function,
+            line,
+            false,
+        );
     }
 }
 
@@ -561,7 +552,7 @@ fn main() -> ExitCode {
     }
 
     // Build cross-reference
-    let mut xref = CrossRef::new();
+    let mut xref = CrossRef::default();
     let mut streams = StreamTable::new();
 
     for file in &args.files {
@@ -586,7 +577,7 @@ fn main() -> ExitCode {
                 // In non-combined mode, print and reset after each file
                 if !args.combined {
                     print_xref(&xref, args.width, args.silent, &mut *output_file);
-                    xref = CrossRef::new();
+                    xref = CrossRef::default();
                 }
             }
             _ => {

cc/ir/inline.rs

@@ -1239,7 +1239,7 @@ mod tests {
     #[test]
     fn test_analyze_simple_function() {
         let func = make_simple_func("test", true);
-        let mut module = Module::new();
+        let mut module = Module::default();
         module.functions.push(func);
 
         let call_counts = build_call_count_map(&module);
@@ -1337,7 +1337,7 @@ mod tests {
     #[test]
     fn test_address_taken_function_not_removed() {
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Create a static function "handler" that would be removed if not address-taken
         let mut handler = Function::new("handler", types.int_id);
@@ -1404,7 +1404,7 @@ mod tests {
         // are NOT removed by dead function elimination.
         // This tests the fix for: static const struct { func_ptr fn; } = { my_func };
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Create a static function "callback" with no direct callers
         let mut callback = Function::new("callback", types.int_id);
@@ -1463,7 +1463,7 @@ mod tests {
     fn test_global_struct_initializer_func_ref_preserved() {
         // Test function refs inside struct initializers in globals
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Create static function "my_handler"
         let mut handler = Function::new("my_handler", types.int_id);
@@ -1516,7 +1516,7 @@ mod tests {
     fn test_global_array_initializer_func_ref_preserved() {
         // Test function refs inside array initializers in globals
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Create static function "arr_func"
         let mut func = Function::new("arr_func", types.int_id);

cc/ir/linearize.rs

@@ -214,7 +214,7 @@ impl<'a> Linearizer<'a> {
         target: &'a Target,
     ) -> Self {
         Self {
-            module: Module::new(),
+            module: Module::default(),
             current_func: None,
             current_bb: None,
             next_pseudo: 0,

cc/ir/mod.rs

@@ -453,7 +453,7 @@ impl fmt::Display for MemoryOrder {
 // ============================================================================
 
 /// Unique ID for a pseudo (virtual register)
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub struct PseudoId(pub u32);
 
 impl fmt::Display for PseudoId {
@@ -463,9 +463,10 @@ impl fmt::Display for PseudoId {
 }
 
 /// Type of pseudo value
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub enum PseudoKind {
     /// Void (no value)
+    #[default]
     Void,
     /// Undefined value
     Undef,
@@ -484,7 +485,7 @@ pub enum PseudoKind {
 }
 
 /// A pseudo (virtual register or value) in SSA form
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Pseudo {
     pub id: PseudoId,
     pub kind: PseudoKind,
@@ -498,16 +499,6 @@ impl PartialEq for Pseudo {
     }
 }
 
-impl Default for Pseudo {
-    fn default() -> Self {
-        Self {
-            id: PseudoId(0),
-            kind: PseudoKind::Void,
-            name: None,
-        }
-    }
-}
-
 impl Pseudo {
     /// Create an undefined pseudo
     pub fn undef(id: PseudoId) -> Self {
@@ -1722,7 +1713,7 @@ impl GlobalDef {
 // ============================================================================
 
 /// A module containing multiple functions
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Module {
     /// Functions
     pub functions: Vec<Function>,
@@ -1749,22 +1740,6 @@ pub struct Module {
 }
 
 impl Module {
-    /// Create a new module
-    pub fn new() -> Self {
-        Self {
-            functions: Vec::new(),
-            globals: Vec::new(),
-            strings: Vec::new(),
-            wide_strings: Vec::new(),
-            debug: false,
-            source_files: Vec::new(),
-            extern_symbols: HashSet::new(),
-            extern_tls_symbols: HashSet::new(),
-            comp_dir: None,
-            source_name: None,
-        }
-    }
-
     /// Add a function
     pub fn add_function(&mut self, func: Function) {
         self.functions.push(func);
@@ -1857,12 +1832,6 @@ impl Module {
     }
 }
 
-impl Default for Module {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl fmt::Display for Module {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Globals
@@ -2060,7 +2029,7 @@ mod tests {
     #[test]
     fn test_module() {
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         module.add_global("counter", types.int_id, Initializer::Int(0));
 
@@ -2073,7 +2042,7 @@ mod tests {
 
     #[test]
     fn test_module_extern_symbols() {
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // New module should have empty extern_symbols
         assert!(module.extern_symbols.is_empty());
@@ -2181,7 +2150,7 @@ mod tests {
     #[test]
     fn test_add_global_aligned_tentative_definition() {
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Add a tentative definition (no initializer)
         module.add_global_aligned("x", types.int_id, Initializer::None, None, false);
@@ -2198,7 +2167,7 @@ mod tests {
     #[test]
     fn test_add_global_aligned_non_tentative_not_replaced() {
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Add a real definition (with initializer)
         module.add_global_aligned("x", types.int_id, Initializer::Int(10), None, false);
@@ -2212,7 +2181,7 @@ mod tests {
     #[test]
     fn test_add_global_tls_aligned_tentative_definition() {
         let types = TypeTable::new(&Target::host());
-        let mut module = Module::new();
+        let mut module = Module::default();
 
         // Add a TLS tentative definition
         module.add_global_tls_aligned("tls_var", types.int_id, Initializer::None, None, false);

cc/parse/ast.rs

@@ -1032,27 +1032,17 @@ pub enum ExternalDecl {
 }
 
 /// A translation unit (entire source file)
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct TranslationUnit {
     pub items: Vec<ExternalDecl>,
 }
 
 impl TranslationUnit {
-    pub fn new() -> Self {
-        TranslationUnit { items: Vec::new() }
-    }
-
     pub fn add(&mut self, item: ExternalDecl) {
         self.items.push(item);
     }
 }
 
-impl Default for TranslationUnit {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 // ============================================================================
 // Tests
 // ============================================================================
@@ -1311,7 +1301,7 @@ mod tests {
         let x_sym = symbols
             .declare(Symbol::variable(x_name, types.int_id, 0))
             .unwrap();
-        let mut tu = TranslationUnit::new();
+        let mut tu = TranslationUnit::default();
 
         // Add a declaration
         let decl = Declaration::simple(x_sym, types.int_id, None);