fix(parsers/python): guard alias resolution to single unconditional binding (BUG-NEW 12)

Python hunk of the alias-guard (ruby hunk ships in the ruby PR). Local-only; not pushed.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: gadievron

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

@@ -203,23 +203,76 @@ def _build_alias_map(self, tree: ast.AST, caller_file: str) -> Dict[str, str]:
         (same-file or via the global single-name index) to a user function. This
         lets `fn = helper; fn()` recover the `helper` edge. Class/method targets
         are out of scope (only ast.Name = ast.Name single-target assigns).
+
+        SINGLE-UNCONDITIONAL-ASSIGNMENT GUARD: an alias is kept ONLY when the
+        name is bound exactly once AND at the function/module top level (a direct
+        statement of the body, not nested inside an If/For/While/Try/With or any
+        other block). A name bound 2+ times (last-write-wins) or bound inside a
+        conditional/loop/try/with is a "maybe" binding; resolving it would assert
+        a maybe as definite, so we drop it and let `x()` fall through to normal
+        resolution (no edge). Precision over recall.
         """
-        aliases: Dict[str, str] = {}
+        # Count EVERY assignment to each name anywhere in the body (any nesting,
+        # both Assign targets and AnnAssign), so a reassignment or a conditional
+        # rebinding disqualifies the name even if one binding is top-level.
+        assign_counts: Dict[str, int] = {}
         for node in ast.walk(tree):
-            if not isinstance(node, ast.Assign):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    for name in self._assigned_names(target):
+                        assign_counts[name] = assign_counts.get(name, 0) + 1
+            elif isinstance(node, ast.AnnAssign) and node.value is not None:
+                for name in self._assigned_names(node.target):
+                    assign_counts[name] = assign_counts.get(name, 0) + 1
+
+        # Only consider candidate aliases declared at the body's TOP LEVEL.
+        top_level = self._function_body_statements(tree)
+        aliases: Dict[str, str] = {}
+        for stmt in top_level:
+            if not isinstance(stmt, ast.Assign):
                 continue
-            if not isinstance(node.value, ast.Name):
+            if not isinstance(stmt.value, ast.Name):
                 continue
-            for target in node.targets:
-                if not isinstance(target, ast.Name):
-                    continue
-                if target.id == node.value.id:
-                    continue
-                resolved = self._resolve_simple_call(node.value.id, caller_file)
-                if resolved:
-                    aliases[target.id] = resolved
+            if len(stmt.targets) != 1:
+                continue
+            target = stmt.targets[0]
+            if not isinstance(target, ast.Name):
+                continue
+            if target.id == stmt.value.id:
+                continue
+            # GUARD: bound exactly once across the whole body (single +
+            # unconditional, because a conditional binding would push the
+            # top-level count higher OR not appear at top level at all).
+            if assign_counts.get(target.id, 0) != 1:
+                continue
+            resolved = self._resolve_simple_call(stmt.value.id, caller_file)
+            if resolved:
+                aliases[target.id] = resolved
         return aliases
 
+    @staticmethod
+    def _assigned_names(target: ast.AST):
+        """Yield the simple Name ids bound by an assignment target (recursively
+        through tuple/list unpacking)."""
+        if isinstance(target, ast.Name):
+            yield target.id
+        elif isinstance(target, (ast.Tuple, ast.List)):
+            for elt in target.elts:
+                yield from CallGraphBuilder._assigned_names(elt)
+
+    @staticmethod
+    def _function_body_statements(tree: ast.AST) -> List[ast.stmt]:
+        """Return the top-level statements of the analysed function body.
+
+        The extractor's `code` includes the `def` line, so a single function
+        parses to Module(body=[FunctionDef]); the real body is that def's body.
+        Fall back to the module body for bare module-level code.
+        """
+        body = getattr(tree, 'body', [])
+        if len(body) == 1 and isinstance(body[0], (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return list(body[0].body)
+        return list(body)
+
     def _resolve_local_function(self, func_name: str, caller_file: str) -> Optional[str]:
         """Resolve a bare name to a same-file, non-method user function.
 

libs/openant-core/tests/parsers/python/test_call_graph_builder_u8.py

@@ -81,6 +81,44 @@ def test_function_value_alias_resolves():
     )
 
 
+# ---------------------------------------------------- [12] single-assign GUARD
+def test_alias_reassignment_not_resolved():
+    """GUARD (reassignment): `fn = a; fn = b; fn()` is last-write-wins, so the
+    binding is a "maybe". The guard must NOT assert a definite edge to EITHER
+    target — pinned behavior: no alias edge at all (fall through to no edge)."""
+    builder = _build({
+        "m.py": (
+            "def a():\n    return 1\n\n"
+            "def b():\n    return 2\n\n"
+            "def main():\n    fn = a\n    fn = b\n    fn()\n"
+        ),
+    })
+    caller = "m.py:main"
+    edges = builder.call_graph.get(caller, [])
+    assert "m.py:a" not in edges and "m.py:b" not in edges, (
+        f"reassigned alias asserted a maybe-binding as definite: {edges}"
+    )
+
+
+def test_alias_conditional_binding_not_resolved():
+    """GUARD (conditional): an alias bound inside if/else is not unconditional,
+    so it must NOT be resolved (no edge to either branch's target)."""
+    builder = _build({
+        "m.py": (
+            "def a():\n    return 1\n\n"
+            "def b():\n    return 2\n\n"
+            "def main(cond):\n"
+            "    if cond:\n        fn = a\n    else:\n        fn = b\n"
+            "    fn()\n"
+        ),
+    })
+    caller = "m.py:main"
+    edges = builder.call_graph.get(caller, [])
+    assert "m.py:a" not in edges and "m.py:b" not in edges, (
+        f"conditional alias resolved despite non-unconditional binding: {edges}"
+    )
+
+
 # ---------------------------------------------------------------- [27]
 def test_import_module_call_does_not_false_link_to_samename_free_fn():
     """`import alpha; alpha.run()` must NOT link caller -> free fn `alpha`."""