perf(native): replace O(n²) type-map dedup with O(n) write-then-dedup

set_type_map_entry previously scanned the entire Vec on every write to
enforce first-write-wins semantics, giving O(n²) construction for files
with many field definitions (e.g. 3 entries per field × N fields × N
scan per write). push_return_type_entry in javascript.rs had the same
pattern.

Replace with a two-phase approach: all writes are plain Vec pushes
(O(1) each), and a single dedup_type_map() pass collapses duplicates
at the end of each extractor's extract() call (O(n) total). The new
helper uses a HashMap drain to keep the highest-confidence entry per
key, with first-write-wins on ties — identical semantics to before.

Adds dedup_type_map() call to all 13 extractors that populate type_map,
and to return_type_map in javascript.rs. Includes unit tests covering
empty, no-duplicate, highest-confidence-wins, and tie-breaking cases.

Author: carlos-alm

crates/codegraph-core/src/extractors/c.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for CExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_c_node);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &C_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_c_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/cpp.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for CppExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_cpp_node);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &CPP_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_cpp_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/csharp.rs

@@ -15,6 +15,7 @@ impl SymbolExtractor for CSharpExtractor {
         reclassify_csharp_implements(&mut symbols);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &CSHARP_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_csharp_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/cuda.rs

@@ -34,6 +34,7 @@ impl SymbolExtractor for CudaExtractor {
         // fires for CUDA files just like it does for C++ files. Mirrors the
         // third walk in `cpp.rs`.
         walk_tree(&tree.root_node(), source, &mut symbols, match_cuda_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/go.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for GoExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_go_node);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &GO_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_go_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/helpers.rs

@@ -958,14 +958,14 @@ pub fn extract_simple_parameters(
 
 // ── Type-map helpers ───────────────────────────────────────────────────────
 
-/// Merge a type-map entry into the sink with highest-confidence-wins semantics,
-/// matching `setTypeMapEntry` in `src/extractors/helpers.ts`.
+/// Append a raw type-map entry (name → type_name at the given confidence)
+/// without deduplication. Call [`dedup_type_map`] once after all entries
+/// have been pushed to collapse duplicates with highest-confidence-wins
+/// semantics.
 ///
-/// If the key already exists with equal-or-higher confidence the new entry is
-/// silently dropped; otherwise the old entry is replaced.  This prevents
-/// duplicate entries from accumulating when the same bare key is written
-/// multiple times (e.g. two class expressions in one file that both define a
-/// field with the same name).
+/// This is the write half of a two-phase approach: accumulate all entries
+/// cheaply (O(1) per write), then deduplicate once in O(n) at the end of
+/// extraction — avoiding the previous O(n²) scan-per-write pattern.
 ///
 /// Mirrors `setTypeMapEntry` in `src/extractors/helpers.ts`.
 pub fn set_type_map_entry(
@@ -978,14 +978,6 @@ pub fn set_type_map_entry(
     if name.is_empty() {
         return;
     }
-    // Scan for an existing entry with the same key.
-    if let Some(existing) = symbols.type_map.iter_mut().find(|e| e.name == name) {
-        if confidence > existing.confidence {
-            existing.type_name = type_name.into();
-            existing.confidence = confidence;
-        }
-        return;
-    }
     symbols.type_map.push(TypeMapEntry {
         name,
         type_name: type_name.into(),
@@ -996,9 +988,8 @@ pub fn set_type_map_entry(
 /// Record a parameter name → type binding in the type-map sink, using
 /// the default confidence of `0.9` shared by every Rust extractor.
 ///
-/// Delegates to [`set_type_map_entry`] so duplicate keys are deduplicated with
-/// highest-confidence-wins semantics (first-write-wins at the uniform 0.9
-/// confidence), matching `setTypeMapEntry` in `src/extractors/helpers.ts`.
+/// Delegates to [`set_type_map_entry`]. Call [`dedup_type_map`] once after
+/// all entries have been pushed to collapse duplicates.
 pub fn push_type_map_entry(
     symbols: &mut FileSymbols,
     name: impl Into<String>,
@@ -1007,6 +998,38 @@ pub fn push_type_map_entry(
     set_type_map_entry(symbols, name, type_name, 0.9);
 }
 
+/// Deduplicate a type-map `Vec` in-place, keeping the highest-confidence
+/// entry per key (first-write-wins on ties, matching `setTypeMapEntry` in
+/// `src/extractors/helpers.ts`).
+///
+/// This is the read half of the two-phase write-then-dedup approach used by
+/// all extractors. Call it once at the end of each `extract()` implementation
+/// after all tree-walk passes have completed, for both `symbols.type_map` and
+/// `symbols.return_type_map` when applicable.
+///
+/// Complexity: O(n) where n = number of entries (including duplicates).
+pub fn dedup_type_map(entries: &mut Vec<TypeMapEntry>) {
+    if entries.len() <= 1 {
+        return;
+    }
+    use std::collections::HashMap;
+    // Drain all entries into a HashMap, keeping the highest-confidence value
+    // per key. On ties the first entry seen wins (insertion-order preserved
+    // by the `if conf > prev` guard), matching the previous first-write-wins
+    // behaviour of the old per-entry linear scan.
+    let mut map: HashMap<String, TypeMapEntry> = HashMap::with_capacity(entries.len());
+    for e in entries.drain(..) {
+        match map.get(&e.name) {
+            None => { map.insert(e.name.clone(), e); }
+            Some(prev) if e.confidence > prev.confidence => {
+                map.insert(e.name.clone(), e);
+            }
+            _ => {}
+        }
+    }
+    entries.extend(map.into_values());
+}
+
 /// C-family `declaration` / `parameter_declaration` type-map matcher.
 ///
 /// The cpp / cuda / c extractors all emit verbatim copies of the same
@@ -1061,3 +1084,76 @@ where
         _ => {}
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::TypeMapEntry;
+
+    fn entry(name: &str, type_name: &str, confidence: f64) -> TypeMapEntry {
+        TypeMapEntry { name: name.to_string(), type_name: type_name.to_string(), confidence }
+    }
+
+    #[test]
+    fn dedup_empty() {
+        let mut v: Vec<TypeMapEntry> = vec![];
+        dedup_type_map(&mut v);
+        assert!(v.is_empty());
+    }
+
+    #[test]
+    fn dedup_single() {
+        let mut v = vec![entry("x", "Foo", 0.9)];
+        dedup_type_map(&mut v);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v[0].name, "x");
+    }
+
+    #[test]
+    fn dedup_no_duplicates() {
+        let mut v = vec![entry("x", "Foo", 0.9), entry("y", "Bar", 0.9)];
+        dedup_type_map(&mut v);
+        assert_eq!(v.len(), 2);
+    }
+
+    #[test]
+    fn dedup_keeps_highest_confidence() {
+        // Lower confidence written first, higher written second — higher wins.
+        let mut v = vec![
+            entry("x", "Low", 0.6),
+            entry("x", "High", 0.9),
+        ];
+        dedup_type_map(&mut v);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v[0].type_name, "High");
+        assert_eq!(v[0].confidence, 0.9);
+    }
+
+    #[test]
+    fn dedup_first_write_wins_on_equal_confidence() {
+        // Two entries with equal confidence — first one wins.
+        let mut v = vec![
+            entry("x", "First", 0.9),
+            entry("x", "Second", 0.9),
+        ];
+        dedup_type_map(&mut v);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v[0].type_name, "First");
+    }
+
+    #[test]
+    fn dedup_mixed_keys() {
+        let mut v = vec![
+            entry("a", "A1", 0.6),
+            entry("b", "B1", 0.9),
+            entry("a", "A2", 0.9),  // higher — wins for "a"
+            entry("b", "B2", 0.7),  // lower  — loses for "b"
+        ];
+        dedup_type_map(&mut v);
+        assert_eq!(v.len(), 2);
+        let a = v.iter().find(|e| e.name == "a").expect("a present");
+        let b = v.iter().find(|e| e.name == "b").expect("b present");
+        assert_eq!(a.type_name, "A2");
+        assert_eq!(b.type_name, "B1");
+    }
+}

crates/codegraph-core/src/extractors/java.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for JavaExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_java_node);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &JAVA_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_java_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/javascript.rs

@@ -41,6 +41,9 @@ impl SymbolExtractor for JsExtractor {
         // Phase 8.3c–8.3f: points-to bindings (params, this-rebinding, arrays,
         // spread, for-of, object rest/props) for the pts constraint solver.
         walk_tree(&tree.root_node(), source, &mut symbols, match_js_pts_bindings);
+        // Collapse duplicate keys accumulated during the tree walks (O(n)).
+        dedup_type_map(&mut symbols.type_map);
+        dedup_type_map(&mut symbols.return_type_map);
         symbols
     }
 }
@@ -635,12 +638,10 @@ fn find_return_new_expr_type<'a>(body: &Node<'a>, source: &'a [u8]) -> Option<&'
     None
 }
 
-/// Insert `(fn_name → type_name)` into `return_type_map`, keeping the highest-confidence entry.
+/// Append a `(fn_name → type_name)` entry to `return_type_map`.
+/// Deduplication (highest-confidence-wins) is handled in bulk by
+/// [`dedup_type_map`] at the end of `extract()`.
 fn push_return_type_entry(symbols: &mut FileSymbols, fn_name: &str, type_name: &str, confidence: f64) {
-    if let Some(pos) = symbols.return_type_map.iter().position(|e| e.name == fn_name) {
-        if symbols.return_type_map[pos].confidence >= confidence { return; }
-        symbols.return_type_map.swap_remove(pos);
-    }
     symbols.return_type_map.push(TypeMapEntry {
         name: fn_name.to_string(),
         type_name: type_name.to_string(),

crates/codegraph-core/src/extractors/kotlin.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for KotlinExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_kotlin_node);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &KOTLIN_AST_CONFIG);
         walk_tree(&tree.root_node(), source, &mut symbols, match_kotlin_type_map);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }

crates/codegraph-core/src/extractors/php.rs

@@ -13,6 +13,7 @@ impl SymbolExtractor for PhpExtractor {
         walk_tree(&tree.root_node(), source, &mut symbols, match_php_node);
         walk_tree(&tree.root_node(), source, &mut symbols, match_php_type_map);
         walk_ast_nodes_with_config(&tree.root_node(), source, &mut symbols.ast_nodes, &PHP_AST_CONFIG);
+        dedup_type_map(&mut symbols.type_map);
         symbols
     }
 }