fix(parsers/c): resolve static-inline functions in included headers

`_is_visible_from` rejected any cross-file `static` callee, which is correct
for a `.c` translation unit but wrong for a `static inline` function in an
`#include`d header (the header-inline idiom — every including TU gets its own
copy and can call it). The include-resolution loop found the header callee via
`include_map`, then dropped the edge as internal-linkage.

Fix is scoped to the include-resolution site only: a candidate whose file ends
in a header extension (.h/.hpp/.hxx/.hh) is visible regardless of `static`. The
repo-wide unique-name fallback and the prototype fallback stay strict — a
`static` helper in another `.c` still does not resolve cross-TU.

Tests: tests/parsers/c/test_c_static_inline_header_resolution.py (static-inline
header resolves; static-in-other-.c still rejected; extern header still
resolves). Precision invariant preserved:
  $ pytest tests/parsers/c/test_c_static_inline_header_resolution.py \
           tests/parsers/c/test_c_call_resolution_precision.py -q
  12 passed in 0.66s

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

Author: gadievron

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

@@ -497,9 +497,18 @@ def _resolve_call(self, call_name: str, caller_file: str,
                 func_data = self.functions.get(func_id, {})
                 fname = func_data.get('name', '')
                 base_name = fname.split('::')[-1] if '::' in fname else fname
-                # A static function in an included header has internal linkage
-                # and is not callable from the including file.
-                if base_name == call_name and self._is_visible_from(func_id, caller_file):
+                # A function in an INCLUDED header is callable from the including
+                # TU regardless of `static`: a `static inline` header helper (the
+                # C header-inline idiom) is copied into every includer. The
+                # cross-file static-linkage rejection in _is_visible_from is
+                # correct only for a .c TU, so it must not gate an included-header
+                # candidate. (Repo-wide and prototype fallbacks below stay strict.)
+                header_candidate = func_data.get('file_path', '').endswith(
+                    ('.h', '.hpp', '.hxx', '.hh')
+                )
+                if base_name == call_name and (
+                    header_candidate or self._is_visible_from(func_id, caller_file)
+                ):
                     return func_id
 
         # 3. Unique name match across entire repo

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

@@ -0,0 +1,76 @@
+"""Bug 2 regression: a `static inline` function defined in an INCLUDED header
+is callable from the including translation unit (the header-inline idiom — each
+TU gets its own copy). The resolver dropped the edge because `_is_visible_from`
+treated any cross-file `static` as internal-linkage-invisible, which is correct
+for a `.c` translation unit but wrong for an included `.h` header.
+
+Paired must-preserve: tests/parsers/c/test_c_call_resolution_precision.py
+::test_unique_name_fallback_skips_static_in_other_file — a `static` fn in another
+`.c` must STILL NOT resolve cross-TU. This fix only un-blocks included headers.
+"""
+import sys
+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.call_graph_builder import CallGraphBuilder  # noqa: E402
+
+
+def _build(eo):
+    b = CallGraphBuilder(eo)
+    b.build_call_graph()
+    out = b.build() if hasattr(b, "build") else b.export()
+    return out.get("call_graph", {})
+
+
+def test_static_inline_in_included_header_resolves():
+    eo = {
+        "functions": {
+            "m.c:caller": {"name": "caller", "file_path": "m.c",
+                           "code": "int caller(int n){ return helper(n); }"},
+            "h.h:helper": {"name": "helper", "file_path": "h.h",
+                           "is_static": True, "is_inline": True,
+                           "code": "static inline int helper(int x){ return x + 1; }"},
+        },
+        "includes": {"m.c": ["h.h"], "h.h": []},
+    }
+    edges = _build(eo).get("m.c:caller", [])
+    assert "h.h:helper" in edges, f"static-inline header call dropped: {edges}"
+
+
+def test_static_in_other_dot_c_still_rejected():
+    # The #84 precision invariant, re-asserted locally: a static fn in another
+    # .c TU must NOT resolve (no #include relationship; genuinely file-local).
+    eo = {
+        "functions": {
+            "a.c:caller": {"name": "caller", "file_path": "a.c",
+                           "code": "void caller(void){ helper(); }"},
+            "b.c:helper": {"name": "helper", "file_path": "b.c", "is_static": True,
+                           "code": "static void helper(void){}"},
+        },
+        "includes": {"a.c": [], "b.c": []},
+    }
+    edges = _build(eo).get("a.c:caller", [])
+    assert "b.c:helper" not in edges, f"static helper() in b.c wrongly resolved cross-TU: {edges}"
+
+
+def test_non_static_in_included_header_still_resolves():
+    # Guard: a normal (extern) header function must keep resolving (no regression).
+    eo = {
+        "functions": {
+            "m.c:caller": {"name": "caller", "file_path": "m.c",
+                           "code": "int caller(int n){ return ext_helper(n); }"},
+            "api.h:ext_helper": {"name": "ext_helper", "file_path": "api.h",
+                                 "is_static": False,
+                                 "code": "int ext_helper(int x);"},
+        },
+        "includes": {"m.c": ["api.h"], "api.h": []},
+    }
+    edges = _build(eo).get("m.c:caller", [])
+    assert "api.h:ext_helper" in edges, f"extern header call dropped: {edges}"