feat(dataflow): syntactic oracle + factor build_function_pdgs (intraprocedural)

Author: rahlk

codeanalyzer/dataflow/builder.py

@@ -36,7 +36,7 @@
 
 import ast
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Callable, Dict, List, Optional, Set, Tuple
 
 from codeanalyzer.dataflow.access_paths import _PathExtractor, _calls_in
 from codeanalyzer.dataflow.alias import TypeBasedAliasOracle
@@ -127,14 +127,24 @@ def _match_args(
     return tuple(pairs)
 
 
-def build_program_graphs(
+def build_function_pdgs(
     app: PyApplication,
     k: int = DEFAULT_K_LIMIT,
-) -> ProgramGraphsIR:
-    """Build CFG/PDG per callable and the whole-program SDG."""
-    class_idx = _class_index(app)
-    callable_idx = _callable_index(app)
-
+    *,
+    oracle_factory: Callable[[PyCallable], object],
+) -> Tuple[Dict[str, FunctionInfo], Dict[str, ast.AST]]:
+    """Intraprocedural phase only: one ``FunctionInfo`` (CFG → PDG) per
+    callable, keyed by signature, with no SDG/summary/callsite work.
+
+    ``oracle_factory(pycallable)`` supplies the may-alias oracle per callable —
+    ``TypeBasedAliasOracle`` for the L4 path, ``SyntacticOracle`` for L3.
+
+    Returns ``(infos, func_asts)`` rather than bare PDGs so that the L4
+    orchestrator (:func:`build_program_graphs`) still has both the
+    ``FunctionInfo`` records its callsite/summary/SDG phases mutate and the
+    matched def nodes its Phase 2 reads. L3 callers just read ``info.pdg`` per
+    signature and ignore ``func_asts``.
+    """
     infos: Dict[str, FunctionInfo] = {}
     func_asts: Dict[str, ast.AST] = {}
 
@@ -166,7 +176,7 @@ def build_program_graphs(
                 if enclosing_ast is not None:
                     enclosing_locals |= _locals_of(enclosing_ast)
 
-            oracle = TypeBasedAliasOracle(_base_types(pycallable))
+            oracle = oracle_factory(pycallable)
             pdg = build_pdg(
                 func,
                 enclosing_locals=enclosing_locals,
@@ -179,6 +189,21 @@ def build_program_graphs(
             )
             func_asts[pycallable.signature] = func
 
+    return infos, func_asts
+
+
+def build_program_graphs(
+    app: PyApplication,
+    k: int = DEFAULT_K_LIMIT,
+) -> ProgramGraphsIR:
+    """Build CFG/PDG per callable and the whole-program SDG."""
+    class_idx = _class_index(app)
+    callable_idx = _callable_index(app)
+
+    infos, func_asts = build_function_pdgs(
+        app, k, oracle_factory=lambda c: TypeBasedAliasOracle(_base_types(c))
+    )
+
     # Callsites and nested defs, now that every signature is known.
     for sig, info in infos.items():
         pycallable = callable_idx[sig]

codeanalyzer/dataflow/syntactic.py

@@ -0,0 +1,26 @@
+################################################################################
+# Copyright IBM Corporation 2025
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+
+"""The L3 (syntactic) alias oracle: two access paths alias iff they are the
+identical path. Bypasses the type-based may-alias so def-use yields only
+name-equality (textual) edges — the alias-derived edges are the L4 delta."""
+
+from __future__ import annotations
+
+
+class SyntacticOracle:
+    def may_alias(self, path_a: str, path_b: str) -> bool:
+        return path_a == path_b

test/test_v2_l3.py

@@ -1,4 +1,11 @@
+import textwrap
+from pathlib import Path
+
+from codeanalyzer.dataflow.builder import build_function_pdgs
 from codeanalyzer.dataflow.identity import IdentityMap
+from codeanalyzer.dataflow.syntactic import SyntacticOracle
+from codeanalyzer.schema.py_schema import PyApplication
+from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
 
 class _Node:
     def __init__(self, id, start_line, start_column, kind):
@@ -21,3 +28,23 @@ def test_ordinal_ids_for_entry_exit_and_statements():
     assert im.ordinal(1) == "can://python/app/m.py/f()@2:4"
     assert im.ordinal(2) == "can://python/app/m.py/f()@exit"
     assert set(im.node_ids()) == {0, 1, 2}
+
+
+def test_syntactic_oracle_only_identity_aliases():
+    o = SyntacticOracle()
+    assert o.may_alias("x.f", "x.f") is True
+    assert o.may_alias("x.f", "y.f") is False
+    assert o.may_alias("a", "b") is False
+
+
+def test_build_function_pdgs_returns_pdg_per_callable(tmp_path: Path):
+    f = tmp_path / "m.py"
+    f.write_text(textwrap.dedent("def f(a):\n    b = a\n    return b\n"), encoding="utf-8")
+    mod = SymbolTableBuilder(tmp_path, None).build_pymodule_from_file(f)
+    app = PyApplication(symbol_table={"m.py": mod})
+    infos, func_asts = build_function_pdgs(
+        app, k=3, oracle_factory=lambda c: SyntacticOracle()
+    )
+    sig = next(iter(mod.functions.values())).signature
+    assert sig in infos
+    assert infos[sig].pdg.cfg.entry_id is not None