fix(parsers/c): stop same-(file,name) functions collapsing to one func_id

`func_id = "<file>:<name>"` carries no signature or preprocessor condition, and
the store was an unguarded `self.functions[func_id] = ...` (keep-last). Two
functions sharing (file, name) silently overwrote each other, corrupting the
inventory AND the call graph: on tree-sitter, 14 real wasm_store.c
implementations were replaced by their `#else` no-op stubs; C++ overloads
collapsed onto one node so a call into one overload reached the other's callee.

New `_store_function` disambiguates collision-only (unique names keep the exact
`path:name` id — the hundreds of hardcoded id literals in the suite are
untouched):
  - SAME signature (#ifdef/#else, ODR-dup): keep ONE node, prefer the larger
    body — the stub is shorter regardless of which arm tree-sitter emits first.
  - DIFFERENT signature (overload): both are real; fold a COLON-FREE signature
    discriminator into the func_id key only. `name` stays bare so the call-graph
    builder (which resolves by `name`) still finds both. Colon-free because
    downstream id splits rsplit on ':' (std::string -> std..string).

Both store sites (process-function + lambda) route through the helper.

Tests: tests/parsers/c/test_c_collision_discriminator.py (overloads survive,
callees not conflated, #ifdef keeps larger body, ids colon-free, unique-name id
byte-identical):
  $ pytest tests/parsers/c/test_c_collision_discriminator.py -q
  5 passed in 0.47s
  $ pytest tests/parsers/c/ -q
  71 passed in 5.71s

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: gadievron

libs/openant-core/parsers/c/function_extractor.py

@@ -230,6 +230,62 @@ def _get_parameters(self, node, source: bytes) -> List[str]:
                 params.append('...')
         return params
 
+    @staticmethod
+    def _signature_discriminator(parameters: List[str]) -> str:
+        """A deterministic, COLON-FREE signature string for the parameter list.
+
+        Colon-free is mandatory: the func_id is split on ':' downstream
+        (`core/diff_filter.py`, `utilities/agentic_enhancer/repository_index.py`
+        rsplit on ':' to recover the file), so any colon a C++ type carries
+        (`std::string`, a ternary default arg) is mapped to '.' here.
+        """
+        joined = ','.join(p.strip() for p in parameters)
+        joined = ' '.join(joined.split())  # collapse newlines/runs of whitespace
+        return joined.replace(':', '.')
+
+    @staticmethod
+    def _same_signature(a: dict, b: dict) -> bool:
+        """Two definitions share a signature iff their parameter lists match.
+
+        Identical params => a redefinition of the SAME function under a different
+        preprocessor branch (#ifdef/#else) or an ODR-duplicate. Different params
+        => a genuine C++ overload.
+        """
+        return a.get('parameters', []) == b.get('parameters', [])
+
+    def _store_function(self, func_id: str, func_data: dict) -> None:
+        """Store a function, disambiguating same-(file,name) collisions instead
+        of silently overwriting (Bug 1: #ifdef/#else stubs and C++ overloads
+        collapsed onto one node — see reachability-bugs.md / bug-3482.md).
+
+        Collision-only: when func_id is free, store byte-identically (the 299
+        hardcoded id literals across the suite depend on unique names keeping the
+        plain `path:name` id). On a collision:
+          - SAME signature -> keep ONE node, prefer the larger body. The #else
+            stub is shorter than the real implementation regardless of which
+            preprocessor arm tree-sitter emits first, so this is order- and
+            direction-independent.
+          - DIFFERENT signature -> a genuine overload; both are real. Mint a
+            distinct key by folding the colon-free signature into the func_id.
+            The `name` field is left bare (`area`, not `area(int,int)`) because
+            the call-graph builder resolves calls by `name` (functions_by_name),
+            so both overloads stay findable. (Contrast bug [39], which folds the
+            template-arg discriminator into the NAME — correct there because a
+            template call is written `g<int>`; an overload call is written bare.)
+        """
+        existing = self.functions.get(func_id)
+        if existing is None:
+            self.functions[func_id] = func_data
+            return
+        if self._same_signature(existing, func_data):
+            if len(func_data.get('code', '')) > len(existing.get('code', '')):
+                self.functions[func_id] = func_data
+            return
+        overload_id = f"{func_id}({self._signature_discriminator(func_data.get('parameters', []))})"
+        prior = self.functions.get(overload_id)
+        if prior is None or len(func_data.get('code', '')) > len(prior.get('code', '')):
+            self.functions[overload_id] = func_data
+
     def _find_function_declarator(self, node):
         """Find the function_declarator within a declarator tree."""
         if node.type == 'function_declarator':
@@ -520,7 +576,7 @@ def _process_function_node(self, node, source: bytes, relative_path: str,
             'class_name': class_name,
         }
 
-        self.functions[func_id] = func_data
+        self._store_function(func_id, func_data)
         self.stats['total_functions'] += 1
 
         if is_static:
@@ -559,7 +615,7 @@ def _process_lambda_declaration(self, node, source: bytes, relative_path: str,
             full_name = (namespace_prefix + name
                          if namespace_prefix and '::' not in name else name)
             func_id = f"{relative_path}:{full_name}"
-            self.functions[func_id] = {
+            self._store_function(func_id, {
                 'name': full_name,
                 'file_path': relative_path,
                 'start_line': node.start_point[0] + 1,
@@ -572,7 +628,7 @@ def _process_lambda_declaration(self, node, source: bytes, relative_path: str,
                 'is_inline': False,
                 'unit_type': 'lambda',
                 'class_name': None,
-            }
+            })
             self.stats['total_functions'] += 1
             self.stats['by_type']['lambda'] = self.stats['by_type'].get('lambda', 0) + 1
 

libs/openant-core/tests/parsers/c/test_c_collision_discriminator.py

@@ -0,0 +1,108 @@
+"""Bug 1 regression: same-(file,name) C/C++ functions must not collapse to one
+`func_id`. Two trigger families, two policies (see reachability-bugs.md Bug 1):
+
+  * C++ overloads — `area(int)` and `area(int,int)` are BOTH real. They must
+    survive as two distinct func_ids, and each must keep its OWN call edges
+    (the conflation bug routed a call to overload-1 into overload-2's callee).
+    The discriminator is folded into the func_id KEY only; the `name` field
+    stays bare (`area`) so name-based call resolution still finds both.
+  * `#ifdef`/`#else` redefinition — same name, same signature, different body.
+    Only one is the compiled implementation; keep a SINGLE node and prefer the
+    larger body (the `#else` stub is shorter regardless of source order).
+
+Plus a regression guard: a uniquely-named function's id is byte-identical to the
+pre-fix `path:name` form (the collision-only contract — non-colliding ids never
+change, so the 299 hardcoded id literals across the suite are untouched).
+"""
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+_CORE = Path(__file__).resolve().parents[3]
+if str(_CORE) not in sys.path:
+    sys.path.insert(0, str(_CORE))
+
+pytest.importorskip("tree_sitter_c")
+
+from parsers.c.function_extractor import FunctionExtractor  # noqa: E402
+from parsers.c.call_graph_builder import CallGraphBuilder  # noqa: E402
+
+
+def _extract(filename: str, source: str) -> dict:
+    repo = Path(tempfile.mkdtemp()).resolve()
+    fp = repo / filename
+    fp.write_text(source)
+    ex = FunctionExtractor(str(repo))
+    ex.process_file(fp)
+    return ex.functions
+
+
+def test_cpp_overloads_both_survive():
+    fns = _extract("ovl.cpp",
+                   "int area(int s){return s*s;}\n"
+                   "int area(int w,int h){return w*h;}\n")
+    areas = [fid for fid, d in fns.items() if d["name"] == "area"]
+    assert len(areas) == 2, f"both overloads must survive; got {areas}"
+    assert len({fid for fid in areas}) == 2, "overload func_ids must be distinct"
+
+
+def test_overload_ids_are_colon_free_in_name_part():
+    # The discriminator must not introduce a colon into the name part of the id
+    # (downstream diff_filter / repository_index rsplit on ':').
+    fns = _extract("ovl.cpp",
+                   "int f(int a){return a;}\n"
+                   "int f(const char* s,int n){return n;}\n")
+    for fid, d in fns.items():
+        if d["name"] != "f":
+            continue
+        name_part = fid.split(":", 1)[1]  # everything after the path colon
+        assert ":" not in name_part, f"colon leaked into discriminated id: {fid!r}"
+
+
+def test_ifdef_else_keeps_larger_body_not_stub():
+    # tree-sitter parses BOTH preprocessor arms; the #else stub comes last and,
+    # pre-fix, overwrote the real implementation. Prefer the larger body.
+    src = (
+        "#ifdef FEATURE\n"
+        "int run(int n){int t=0;for(int i=0;i<n;i++){t+=i*i;}return t;}\n"
+        "#else\n"
+        "int run(int n){(void)n;return 0;}\n"
+        "#endif\n"
+    )
+    fns = _extract("if.c", src)
+    runs = [d for d in fns.values() if d["name"] == "run"]
+    assert len(runs) == 1, f"#ifdef/#else same-sig must keep ONE node; got {len(runs)}"
+    assert "for" in runs[0]["code"], f"kept the stub, not the real impl: {runs[0]['code']!r}"
+
+
+def test_overload_callees_not_conflated():
+    # The real consequence of the bug: a call into one overload must reach ITS
+    # callee, not the other overload's. Mirrors /tmp/bugrepro/conf.cpp.
+    src = (
+        "void alpha(){}\n"
+        "void beta(){}\n"
+        "int pick(int a){alpha();return a;}\n"
+        "int pick(int a,int b){beta();return a+b;}\n"
+    )
+    fns = _extract("conf.cpp", src)
+    b = CallGraphBuilder({"functions": fns, "includes": {}})
+    b.build_call_graph()
+    out = b.build() if hasattr(b, "build") else b.export()
+    cg = out.get("call_graph", {})
+    pick_ids = [fid for fid, d in fns.items() if d["name"] == "pick"]
+    assert len(pick_ids) == 2, f"both pick overloads must exist; got {pick_ids}"
+    all_pick_edges = {e for fid in pick_ids for e in cg.get(fid, [])}
+    alpha_id = next(fid for fid, d in fns.items() if d["name"] == "alpha")
+    beta_id = next(fid for fid, d in fns.items() if d["name"] == "beta")
+    assert alpha_id in all_pick_edges, f"alpha() edge lost (conflation): {all_pick_edges}"
+    assert beta_id in all_pick_edges, f"beta() edge lost (conflation): {all_pick_edges}"
+
+
+def test_unique_name_id_is_byte_identical():
+    # Collision-only contract: a uniquely-named function keeps the exact
+    # `path:name` id — no discriminator appended when there is no collision.
+    fns = _extract("u.c", "int solo(int x){return x+1;}\n")
+    ids = [fid for fid, d in fns.items() if d["name"] == "solo"]
+    assert ids == ["u.c:solo"], f"unique-name id changed (would break 299 literals): {ids}"