Barmaja-PyArduino 2.0.0__py3-none-any.whl

Barmaja_PyArduino/symbols.py

@@ -0,0 +1,646 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from enum import Enum
+
+from .errors import NameResolutionError
+from .frontend import FrontendModule
+from .api_registry import HARDWARE_CLASSES
+
+
+LANGUAGE_BUILTINS = frozenset({
+    "print", "round", "min", "max", "abs", "int", "float", "bool", "len", "sum", "enumerate", "range",
+})
+
+
+class SymbolKind(Enum):
+    API = "api"
+    BUILTIN = "builtin"
+    MODULE = "module"
+    FUNCTION = "function"
+    HARDWARE = "hardware"
+    PARAMETER = "parameter"
+    LOCAL = "local"
+
+
+@dataclass(frozen=True, order=True)
+class SymbolId:
+    value: int
+
+    def __str__(self) -> str:
+        return f"S{self.value:04d}"
+
+
+@dataclass
+class Symbol:
+    symbol_id: SymbolId
+    name: str
+    kind: SymbolKind
+    scope_name: str
+    cpp_name: str
+    declaration_line: int | None = None
+    imported: bool = False
+
+    @property
+    def is_user_symbol(self) -> bool:
+        return self.kind not in {SymbolKind.API, SymbolKind.BUILTIN}
+
+
+@dataclass
+class Scope:
+    name: str
+    kind: str
+    symbols: dict[str, Symbol] = field(default_factory=dict)
+    global_names: set[str] = field(default_factory=set)
+
+
+@dataclass(frozen=True)
+class ResolvedModule:
+    frontend: FrontendModule
+    module_scope: Scope
+    function_scopes: dict[str, Scope]
+    bindings: dict[int, Symbol]
+    function_bindings: dict[int, Symbol]
+    parameter_bindings: dict[int, Symbol]
+
+    def symbol_for_name(self, node: ast.Name) -> Symbol:
+        return self.bindings[id(node)]
+
+    def symbol_for_function(self, node: ast.FunctionDef) -> Symbol:
+        return self.function_bindings[id(node)]
+
+    def symbol_for_parameter(self, node: ast.arg) -> Symbol:
+        return self.parameter_bindings[id(node)]
+
+
+class _Mangler:
+    """Deterministic backend identifiers independent of Python spelling.
+
+    User spelling is intentionally absent from the generated identifier. This
+    makes C++ keywords/macros, AVR register names, Arduino names and non-ASCII
+    Python identifiers harmless to the backend.
+    """
+
+    def __init__(self) -> None:
+        self._next = 1
+
+    def user_symbol(self) -> tuple[SymbolId, str]:
+        symbol_id = SymbolId(self._next)
+        self._next += 1
+        return symbol_id, f"_bj_s{symbol_id.value:04d}"
+
+    @staticmethod
+    def synthetic(symbol_id: int, prefix: str) -> tuple[SymbolId, str]:
+        sid = SymbolId(symbol_id)
+        return sid, prefix
+
+
+class SymbolResolver:
+    def __init__(self, frontend: FrontendModule) -> None:
+        self.frontend = frontend
+        self.module = Scope("<module>", "module")
+        self.function_scopes: dict[str, Scope] = {}
+        self.bindings: dict[int, Symbol] = {}
+        self.function_bindings: dict[int, Symbol] = {}
+        self.parameter_bindings: dict[int, Symbol] = {}
+        self._mangler = _Mangler()
+        self._function_nodes: dict[str, ast.FunctionDef] = {}
+        self._function_call_graph: dict[str, set[str]] = {}
+        self._function_module_dependencies: dict[str, set[str]] = {}
+
+    def resolve(self) -> ResolvedModule:
+        self._install_predefined_bindings()
+        self._collect_module_bindings()
+        self._collect_function_scopes()
+        self._resolve_module_body()
+        self._resolve_functions()
+        self._validate_immediate_top_level_function_calls()
+        return ResolvedModule(
+            frontend=self.frontend,
+            module_scope=self.module,
+            function_scopes=self.function_scopes,
+            bindings=self.bindings,
+            function_bindings=self.function_bindings,
+            parameter_bindings=self.parameter_bindings,
+        )
+
+    # ---------- collection ----------
+    def _install_predefined_bindings(self) -> None:
+        # Negative IDs are compiler-predefined and are never emitted as user
+        # storage. Keep ordering deterministic for debugging/tests.
+        next_predefined = -1
+        for name in sorted(self.frontend.api_names):
+            sid, cpp = self._mangler.synthetic(next_predefined, name)
+            next_predefined -= 1
+            self.module.symbols[name] = Symbol(
+                sid, name, SymbolKind.API, self.module.name, cpp, imported=True,
+            )
+        for name in sorted(LANGUAGE_BUILTINS):
+            # An explicitly imported API always wins if a future public surface
+            # deliberately uses the same spelling.
+            if name in self.module.symbols:
+                continue
+            sid, cpp = self._mangler.synthetic(next_predefined, name)
+            next_predefined -= 1
+            self.module.symbols[name] = Symbol(
+                sid, name, SymbolKind.BUILTIN, self.module.name, cpp,
+            )
+
+    def _new_user_symbol(
+        self,
+        name: str,
+        kind: SymbolKind,
+        scope: Scope,
+        node: ast.AST,
+    ) -> Symbol:
+        self._check_protected_binding(name, node)
+        sid, cpp_name = self._mangler.user_symbol()
+        symbol = Symbol(
+            sid,
+            name,
+            kind,
+            scope.name,
+            cpp_name,
+            declaration_line=getattr(node, "lineno", None),
+        )
+        scope.symbols[name] = symbol
+        return symbol
+
+    def _check_protected_binding(self, name: str, node: ast.AST) -> None:
+        existing = self.module.symbols.get(name)
+        if existing and existing.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+            raise self._name_error(
+                f"'{name}' is a protected Barmaja API/builtin name and cannot be rebound.",
+                node,
+            )
+
+    def _collect_module_bindings(self) -> None:
+        for stmt in self.frontend.tree.body:
+            if isinstance(stmt, ast.ImportFrom):
+                continue
+            if isinstance(stmt, ast.FunctionDef):
+                if stmt.name in self._function_nodes:
+                    raise self._name_error(f"Function '{stmt.name}' is defined more than once.", stmt)
+                if stmt.name in self.module.symbols:
+                    # API/builtin conflict or an earlier variable/object conflict.
+                    existing = self.module.symbols[stmt.name]
+                    if existing.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                        self._check_protected_binding(stmt.name, stmt)
+                    raise self._name_error(
+                        f"'{stmt.name}' is already bound at module scope and cannot also be a function.",
+                        stmt,
+                    )
+                sym = self._new_user_symbol(stmt.name, SymbolKind.FUNCTION, self.module, stmt)
+                self._function_nodes[stmt.name] = stmt
+                self.function_bindings[id(stmt)] = sym
+                continue
+            self._collect_module_stmt_bindings(stmt)
+
+    def _collect_module_stmt_bindings(self, stmt: ast.stmt) -> None:
+        if isinstance(stmt, ast.Assign):
+            for target in stmt.targets:
+                self._collect_module_target(target, stmt, self._assignment_kind(stmt))
+            return
+        if isinstance(stmt, ast.AugAssign):
+            self._collect_module_target(stmt.target, stmt, SymbolKind.MODULE)
+            return
+        if isinstance(stmt, ast.For):
+            self._collect_module_target(stmt.target, stmt, SymbolKind.MODULE)
+            for child in stmt.body:
+                self._collect_module_stmt_bindings(child)
+            for child in stmt.orelse:
+                self._collect_module_stmt_bindings(child)
+            return
+        if isinstance(stmt, ast.If):
+            for child in stmt.body + stmt.orelse:
+                self._collect_module_stmt_bindings(child)
+            return
+        if isinstance(stmt, ast.While):
+            for child in stmt.body + stmt.orelse:
+                self._collect_module_stmt_bindings(child)
+            return
+        # FunctionDef is intentionally not descended into here.
+
+    def _assignment_kind(self, stmt: ast.Assign) -> SymbolKind:
+        if (
+            len(stmt.targets) == 1
+            and isinstance(stmt.targets[0], ast.Name)
+            and isinstance(stmt.value, ast.Call)
+            and isinstance(stmt.value.func, ast.Name)
+            and stmt.value.func.id in HARDWARE_CLASSES
+        ):
+            return SymbolKind.HARDWARE
+        return SymbolKind.MODULE
+
+    def _collect_module_target(self, target: ast.AST, owner: ast.AST, kind: SymbolKind) -> None:
+        if isinstance(target, ast.Name):
+            existing = self.module.symbols.get(target.id)
+            if existing is None:
+                self._new_user_symbol(target.id, kind, self.module, owner)
+                return
+            if existing.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                self._check_protected_binding(target.id, owner)
+            if kind == SymbolKind.HARDWARE and existing.kind != SymbolKind.HARDWARE:
+                raise self._name_error(
+                    f"'{target.id}' is already a normal module variable and cannot be rebound as a hardware object.",
+                    owner,
+                )
+            if existing.kind == SymbolKind.FUNCTION:
+                raise self._name_error(
+                    f"'{target.id}' is a function and cannot be rebound as a module variable.",
+                    owner,
+                )
+            return
+        if isinstance(target, (ast.Tuple, ast.List)):
+            for elt in target.elts:
+                self._collect_module_target(elt, owner, SymbolKind.MODULE)
+
+    def _collect_function_scopes(self) -> None:
+        for fn in self.frontend.tree.body:
+            if not isinstance(fn, ast.FunctionDef):
+                continue
+            scope = Scope(fn.name, "function")
+            self.function_scopes[fn.name] = scope
+            globals_by_name = self._collect_global_declarations(fn)
+            scope.global_names.update(globals_by_name)
+
+            parameter_names = {arg.arg for arg in fn.args.args}
+            overlap = parameter_names & scope.global_names
+            if overlap:
+                name = sorted(overlap)[0]
+                raise self._name_error(
+                    f"Function parameter '{name}' cannot also be declared global.",
+                    fn,
+                )
+
+            for arg in fn.args.args:
+                self._check_protected_binding(arg.arg, arg)
+                sym = self._new_user_symbol(arg.arg, SymbolKind.PARAMETER, scope, arg)
+                self.parameter_bindings[id(arg)] = sym
+
+            local_targets: list[tuple[str, ast.AST]] = []
+            self._collect_function_local_targets(fn.body, local_targets)
+            for name, node in local_targets:
+                if name in scope.global_names or name in scope.symbols:
+                    continue
+                self._check_protected_binding(name, node)
+                self._new_user_symbol(name, SymbolKind.LOCAL, scope, node)
+
+            # Restricted global requires an already-known module symbol and may
+            # not target an imported API/builtin/function-only name.
+            for name, global_node in globals_by_name.items():
+                target = self.module.symbols.get(name)
+                if target is None or target.kind in {SymbolKind.API, SymbolKind.BUILTIN, SymbolKind.FUNCTION}:
+                    raise self._name_error(
+                        f"global '{name}' must refer to an existing module variable or hardware object.",
+                        global_node,
+                    )
+                self._validate_global_order(fn, name, global_node)
+
+    def _collect_global_declarations(self, fn: ast.FunctionDef) -> dict[str, ast.Global]:
+        found: dict[str, ast.Global] = {}
+        for node in ast.walk(fn):
+            if isinstance(node, (ast.FunctionDef, ast.Lambda)) and node is not fn:
+                continue
+            if isinstance(node, ast.Global):
+                for name in node.names:
+                    if name in found:
+                        continue
+                    found[name] = node
+        return found
+
+    def _collect_function_local_targets(
+        self,
+        body: list[ast.stmt],
+        out: list[tuple[str, ast.AST]],
+    ) -> None:
+        for stmt in body:
+            if isinstance(stmt, ast.Assign):
+                for target in stmt.targets:
+                    self._append_simple_targets(target, stmt, out)
+            elif isinstance(stmt, ast.AugAssign):
+                self._append_simple_targets(stmt.target, stmt, out)
+            elif isinstance(stmt, ast.For):
+                self._append_simple_targets(stmt.target, stmt, out)
+                self._collect_function_local_targets(stmt.body, out)
+                self._collect_function_local_targets(stmt.orelse, out)
+            elif isinstance(stmt, ast.If):
+                self._collect_function_local_targets(stmt.body, out)
+                self._collect_function_local_targets(stmt.orelse, out)
+            elif isinstance(stmt, ast.While):
+                self._collect_function_local_targets(stmt.body, out)
+                self._collect_function_local_targets(stmt.orelse, out)
+            # Nested defs are rejected by Phase B and not traversed.
+
+    @staticmethod
+    def _append_simple_targets(target: ast.AST, owner: ast.AST, out: list[tuple[str, ast.AST]]) -> None:
+        if isinstance(target, ast.Name):
+            out.append((target.id, owner))
+        elif isinstance(target, (ast.Tuple, ast.List)):
+            for elt in target.elts:
+                SymbolResolver._append_simple_targets(elt, owner, out)
+
+    def _validate_global_order(self, fn: ast.FunctionDef, name: str, global_node: ast.Global) -> None:
+        global_line = getattr(global_node, "lineno", 10**9)
+        for node in ast.walk(fn):
+            if isinstance(node, ast.Name) and node.id == name and getattr(node, "lineno", 10**9) < global_line:
+                raise self._name_error(
+                    f"global '{name}' must appear before that name is used or assigned in the function.",
+                    global_node,
+                )
+
+    # ---------- resolution ----------
+    def _resolve_module_body(self) -> None:
+        for stmt in self.frontend.tree.body:
+            if isinstance(stmt, ast.FunctionDef):
+                continue
+            self._resolve_stmt(stmt, self.module, in_function=False)
+
+    def _resolve_functions(self) -> None:
+        for fn in self.frontend.tree.body:
+            if not isinstance(fn, ast.FunctionDef):
+                continue
+            scope = self.function_scopes[fn.name]
+            self._function_call_graph[fn.name] = set()
+            self._function_module_dependencies[fn.name] = set()
+            for stmt in fn.body:
+                self._resolve_stmt(stmt, scope, in_function=True, current_function=fn.name)
+            for node in ast.walk(fn):
+                if not isinstance(node, ast.Name):
+                    continue
+                sym = self.bindings.get(id(node))
+                if sym and sym.scope_name == self.module.name and sym.kind in {SymbolKind.MODULE, SymbolKind.HARDWARE}:
+                    self._function_module_dependencies[fn.name].add(sym.name)
+
+    def _resolve_stmt(
+        self,
+        stmt: ast.stmt,
+        scope: Scope,
+        *,
+        in_function: bool,
+        current_function: str | None = None,
+    ) -> None:
+        if isinstance(stmt, ast.ImportFrom):
+            return
+        if isinstance(stmt, ast.Global):
+            return
+        if isinstance(stmt, ast.Expr):
+            self._resolve_expr(stmt.value, scope, current_function=current_function)
+            return
+        if isinstance(stmt, ast.Assign):
+            self._resolve_expr(stmt.value, scope, current_function=current_function)
+            for target in stmt.targets:
+                self._resolve_store_target(target, scope, in_function=in_function)
+            return
+        if isinstance(stmt, ast.AugAssign):
+            # AugAssign reads and writes the same binding/value.
+            if isinstance(stmt.target, ast.Name):
+                self._bind_name(stmt.target, scope, ast.Load(), current_function=current_function)
+                self._resolve_store_target(stmt.target, scope, in_function=in_function)
+            elif isinstance(stmt.target, ast.Subscript):
+                self._resolve_expr(stmt.target, scope, current_function=current_function)
+            self._resolve_expr(stmt.value, scope, current_function=current_function)
+            return
+        if isinstance(stmt, ast.If):
+            self._resolve_expr(stmt.test, scope, current_function=current_function)
+            for child in stmt.body + stmt.orelse:
+                self._resolve_stmt(child, scope, in_function=in_function, current_function=current_function)
+            return
+        if isinstance(stmt, ast.While):
+            self._resolve_expr(stmt.test, scope, current_function=current_function)
+            for child in stmt.body + stmt.orelse:
+                self._resolve_stmt(child, scope, in_function=in_function, current_function=current_function)
+            return
+        if isinstance(stmt, ast.For):
+            self._resolve_expr(stmt.iter, scope, current_function=current_function)
+            self._resolve_store_target(stmt.target, scope, in_function=in_function)
+            for child in stmt.body + stmt.orelse:
+                self._resolve_stmt(child, scope, in_function=in_function, current_function=current_function)
+            return
+        if isinstance(stmt, ast.Return):
+            if stmt.value is not None:
+                self._resolve_expr(stmt.value, scope, current_function=current_function)
+            return
+        # no-op statements were structurally validated already.
+
+    def _resolve_store_target(self, target: ast.AST, scope: Scope, *, in_function: bool) -> None:
+        if isinstance(target, ast.Name):
+            self._bind_name(target, scope, ast.Store())
+            return
+        if isinstance(target, (ast.Tuple, ast.List)):
+            for elt in target.elts:
+                self._resolve_store_target(elt, scope, in_function=in_function)
+            return
+        if isinstance(target, ast.Subscript):
+            self._resolve_expr(target.value, scope)
+            self._resolve_expr(target.slice, scope)
+
+    def _resolve_expr(self, node: ast.AST, scope: Scope, *, current_function: str | None = None) -> None:
+        if isinstance(node, ast.Name):
+            sym = self._bind_name(node, scope, node.ctx, current_function=current_function)
+            if current_function and sym.kind == SymbolKind.FUNCTION:
+                self._function_call_graph[current_function].add(sym.name)
+            return
+        if isinstance(node, ast.Constant):
+            return
+        if isinstance(node, ast.JoinedStr):
+            for value in node.values:
+                if isinstance(value, ast.FormattedValue):
+                    self._resolve_expr(value.value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.FormattedValue):
+            self._resolve_expr(node.value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.Call):
+            self._resolve_expr(node.func, scope, current_function=current_function)
+            for arg in node.args:
+                self._resolve_expr(arg, scope, current_function=current_function)
+            for kw in node.keywords:
+                self._resolve_expr(kw.value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.Attribute):
+            self._resolve_expr(node.value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.UnaryOp):
+            self._resolve_expr(node.operand, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.BinOp):
+            self._resolve_expr(node.left, scope, current_function=current_function)
+            self._resolve_expr(node.right, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.Compare):
+            self._resolve_expr(node.left, scope, current_function=current_function)
+            for value in node.comparators:
+                self._resolve_expr(value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.BoolOp):
+            for value in node.values:
+                self._resolve_expr(value, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.IfExp):
+            self._resolve_expr(node.test, scope, current_function=current_function)
+            self._resolve_expr(node.body, scope, current_function=current_function)
+            self._resolve_expr(node.orelse, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.List):
+            for item in node.elts:
+                self._resolve_expr(item, scope, current_function=current_function)
+            return
+        if isinstance(node, ast.Subscript):
+            self._resolve_expr(node.value, scope, current_function=current_function)
+            self._resolve_expr(node.slice, scope, current_function=current_function)
+            return
+
+    def _bind_name(
+        self,
+        node: ast.Name,
+        scope: Scope,
+        ctx: ast.expr_context,
+        *,
+        current_function: str | None = None,
+    ) -> Symbol:
+        name = node.id
+        if scope.kind == "function":
+            if name in scope.global_names:
+                sym = self.module.symbols.get(name)
+            elif name in scope.symbols:
+                sym = scope.symbols[name]
+            else:
+                sym = self.module.symbols.get(name)
+        else:
+            sym = self.module.symbols.get(name)
+
+        if sym is None:
+            raise self._name_error(f"Name '{name}' is not defined.", node)
+
+        self.bindings[id(node)] = sym
+        return sym
+
+    # ---------- module execution-order check ----------
+    def _validate_immediate_top_level_function_calls(self) -> None:
+        def_lines = {
+            name: (getattr(node, "lineno", 0) or 0)
+            for name, node in self._function_nodes.items()
+        }
+
+        for stmt in self.frontend.tree.body:
+            if isinstance(stmt, (ast.FunctionDef, ast.ImportFrom)):
+                continue
+            # The top-level while body executes only after reaching the main
+            # loop; every supported setup assignment/definition is before that point.
+            if isinstance(stmt, ast.While) and stmt is self.frontend.main_loop:
+                continue
+            call_line = getattr(stmt, "lineno", 0) or 0
+
+            # A direct setup-time read cannot see a module variable/object whose
+            # first binding statement has not executed yet. Conditional/branch
+            # availability after an earlier binding is Step 6 definite assignment.
+            for child in ast.walk(stmt):
+                if not isinstance(child, ast.Name) or not isinstance(child.ctx, ast.Load):
+                    continue
+                sym = self.bindings.get(id(child))
+                if not sym or sym.scope_name != self.module.name:
+                    continue
+                if sym.kind not in {SymbolKind.MODULE, SymbolKind.HARDWARE}:
+                    continue
+                decl_line = sym.declaration_line or 0
+                # Compare with the reading node itself, not with the enclosing
+                # top-level statement: a name first bound earlier inside the same
+                # if/for/while body is available here. Branch/loop availability is
+                # decided by the definite-assignment flow phase.
+                read_line = getattr(child, "lineno", call_line) or call_line
+                if decl_line > read_line:
+                    raise self._name_error(
+                        f"Name '{sym.name}' is used before its module definition has executed.",
+                        child,
+                    )
+
+            for called, site_line in self._user_function_call_sites(stmt, call_line):
+                unavailable = self._reachable_functions_defined_after(called, site_line, def_lines)
+                if unavailable:
+                    missing = sorted(unavailable, key=lambda n: def_lines[n])[0]
+                    raise self._name_error(
+                        f"Function '{missing}' is used before its definition has executed.",
+                        stmt,
+                    )
+                unavailable_module = self._reachable_module_dependencies_defined_after(called, site_line)
+                if unavailable_module:
+                    missing = sorted(
+                        unavailable_module,
+                        key=lambda n: self.module.symbols[n].declaration_line or 0,
+                    )[0]
+                    raise self._name_error(
+                        f"Name '{missing}' is used by this function before its module definition has executed.",
+                        stmt,
+                    )
+
+    def _reachable_functions_defined_after(
+        self,
+        start: str,
+        call_line: int,
+        def_lines: dict[str, int],
+    ) -> set[str]:
+        pending = [start]
+        seen: set[str] = set()
+        bad: set[str] = set()
+        while pending:
+            name = pending.pop()
+            if name in seen:
+                continue
+            seen.add(name)
+            if name in def_lines and def_lines[name] > call_line:
+                bad.add(name)
+            pending.extend(self._function_call_graph.get(name, ()))
+        return bad
+
+    def _reachable_module_dependencies_defined_after(self, start: str, call_line: int) -> set[str]:
+        pending = [start]
+        seen: set[str] = set()
+        bad: set[str] = set()
+        while pending:
+            fn_name = pending.pop()
+            if fn_name in seen:
+                continue
+            seen.add(fn_name)
+            for dep_name in self._function_module_dependencies.get(fn_name, ()):
+                symbol = self.module.symbols.get(dep_name)
+                if symbol is not None and (symbol.declaration_line or 0) > call_line:
+                    bad.add(dep_name)
+            pending.extend(self._function_call_graph.get(fn_name, ()))
+        return bad
+
+    def _user_function_call_sites(self, node: ast.AST, default_line: int) -> list[tuple[str, int]]:
+        sites: dict[str, int] = {}
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call) and isinstance(child.func, ast.Name):
+                sym = self.bindings.get(id(child.func))
+                if sym and sym.kind == SymbolKind.FUNCTION:
+                    line = getattr(child, "lineno", default_line) or default_line
+                    # The earliest call site is the strictest availability point.
+                    sites[sym.name] = min(line, sites.get(sym.name, line))
+        return sorted(sites.items(), key=lambda item: (item[1], item[0]))
+
+    def _user_function_calls(self, node: ast.AST) -> set[str]:
+        result: set[str] = set()
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call) and isinstance(child.func, ast.Name):
+                sym = self.bindings.get(id(child.func))
+                if sym and sym.kind == SymbolKind.FUNCTION:
+                    result.add(sym.name)
+        return result
+
+    @staticmethod
+    def _name_error(message: str, node: ast.AST) -> NameResolutionError:
+        col = getattr(node, "col_offset", None)
+        return NameResolutionError(
+            message,
+            line=getattr(node, "lineno", None),
+            column=(col + 1) if col is not None else None,
+            end_line=getattr(node, "end_lineno", None),
+            end_column=getattr(node, "end_col_offset", None),
+        )
+
+
+def resolve_symbols(frontend: FrontendModule) -> ResolvedModule:
+    return SymbolResolver(frontend).resolve()