analyzer

Compose the specialized semantic visitor mixins around a shared analyzer core so traversal, registration, bindings, and rule logic live in smaller modules.

Classes:

• SemanticAnalyzer –

SemanticAnalyzer

SemanticAnalyzer(
    *,
    context: SemanticContext | None = None,
    session: CompilationSession | None = None,
)

Bases: ImportVisitorMixin, DeclarationVisitorMixin, ExpressionVisitorMixin, ControlFlowVisitorMixin, SemanticAnalyzerCore

Walk AST nodes, attach semantic sidecars, and delegate reusable policy to the extracted factories, registries, and binding tables.

Methods:

• analyze –
• analyze_parsed_module –
• visit –

Source code in src/irx/analysis/handlers/base.py

def __init__(
    self,
    *,
    context: SemanticContext | None = None,
    session: CompilationSession | None = None,
) -> None:
    """
    title: Initialize SemanticAnalyzerCore.
    parameters:
      context:
        type: SemanticContext | None
      session:
        type: CompilationSession | None
    """
    self.session = session
    self.context = context or SemanticContext()
    if session is not None:
        self.context.diagnostics = session.diagnostics
    self.factory = SemanticEntityFactory(self.context)
    self.registry = SemanticRegistry(self.context, self.factory)
    self.bindings = VisibleBindings(
        context=self.context,
        factory=self.factory,
        bindings=(
            session.visible_bindings if session is not None else None
        ),
    )

analyze

analyze(node: AST) -> AST

Source code in src/irx/analysis/handlers/base.py

def analyze(self, node: astx.AST) -> astx.AST:
    """
    title: Analyze one AST root.
    parameters:
      node:
        type: astx.AST
    returns:
      type: astx.AST
    """
    if isinstance(node, astx.Module):
        parsed_module = ParsedModule(node.name, node)
        self.analyze_parsed_module(parsed_module, predeclared=False)
    else:
        with self.context.scope("module"):
            self.visit(node)
    self.context.diagnostics.raise_if_errors()
    return node

analyze_parsed_module

analyze_parsed_module(
    parsed_module: ParsedModule, *, predeclared: bool
) -> Module

Source code in src/irx/analysis/handlers/base.py

def analyze_parsed_module(
    self,
    parsed_module: ParsedModule,
    *,
    predeclared: bool,
) -> astx.Module:
    """
    title: Analyze one parsed module.
    parameters:
      parsed_module:
        type: ParsedModule
      predeclared:
        type: bool
    returns:
      type: astx.Module
    """
    with self.context.in_module(parsed_module.key):
        self._visit_module(parsed_module.ast, predeclared=predeclared)
    return parsed_module.ast

visit

visit(node: ImportFromExpr) -> None

Source code in src/irx/analysis/handlers/imports.py

@SemanticAnalyzerCore.visit.dispatch
def visit(self, node: astx.ImportFromExpr) -> None:
    """
    title: Visit ImportFromExpr nodes.
    parameters:
      node:
        type: astx.ImportFromExpr
    """
    self.context.diagnostics.add(
        "Import expressions are not supported in this MVP.",
        node=node,
    )
    self._set_type(node, None)