Semantic Analysis — syntax ঠিক, অর্থ ভুল ধরা

toylang/resolver.py:

"""ToyLang semantic analysis pass 1: name resolution.
Needs: toylang/ast.py (lesson 5).
"""
from dataclasses import dataclass, field
from toylang.ast import (Program, LetStmt, Print, IfStmt,
                         WhileStmt, ExprStmt, VarRef,
                         BinOp, UnaryOp)


@dataclass
class SemanticError:
    msg: str
    line: int
    col: int
    end_col: int

    def render(self):
        return (f"error[sem]: {self.msg} "
                f"@{self.line}:{self.col}-{self.end_col}")


@dataclass
class Decl:
    name: str
    span: tuple          # (line, col, end_col)
    refs: list = field(default_factory=list)   # ref spans


class Resolver:
    """Two responsibilities:
    1. every VarRef -> its Decl (or error)
    2. every duplicate/undeclared -> SemanticError
    """

    def __init__(self):
        self.scopes = [{}]      # scope stack; top = last
        self.errors = []
        self.links = {}         # decl key -> Decl (go-to-definition)

    # ---- scope machinery ------------------------------------------
    def _push(self): self.scopes.append({})

    def _pop(self): self.scopes.pop()

    def _lookup(self, name):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        return None

    def _declare(self, name, span):
        top = self.scopes[-1]
        if name in top:
            prev = top[name]
            self._err(
                f"duplicate declaration of '{name}'",
                span, note_prev=prev.span)
            return
        d = Decl(name, span)
        top[name] = d
        self.links[span] = d
        return d

    def _err(self, msg, span, note_prev=None):
        line, col, end_col = span
        self.errors.append(SemanticError(msg, line, col, end_col))
        if note_prev:
            pl, pc, pe = note_prev
            self.errors.append(SemanticError(
                f"note: previous declaration @{pl}:{pc}", pl, pc, pe))

    # ---- walking ----------------------------------------------------
    def resolve(self, prog: Program):
        for s in prog.stmts:
            self.stmt(s)

    def stmt(self, s):
        m = {LetStmt: self.let_stmt, Print: self.print_stmt,
             IfStmt: self.if_stmt, WhileStmt: self.while_stmt,
             ExprStmt: lambda x: self.expr_stmt(x)}
        m[type(s)](s)

    def let_stmt(self, s):
        self.expr(s.init)               # init-এর refs আগে
        self._declare(s.name, _span(s))

    def print_stmt(self, s):
        self.expr(s.arg)

    def expr_stmt(self, s):
        self.expr(s.expr)

    def if_stmt(self, s):
        self.expr(s.cond)
        self.block(s.then)
        if s.else_ is not None:
            self.block(s.else_)

    def while_stmt(self, s):
        self.expr(s.cond)
        self.block(s.body)

    def block(self, stmts):
        self._push()
        for s in stmts:
            self.stmt(s)
        self._pop()

    # ---- expressions --------------------------------------------------
    def expr(self, e):
        if isinstance(e, VarRef):
            d = self._lookup(e.name)
            if d is None:
                self._err(f"undeclared name '{e.name}'",
                          _span(e))
                return
            d.refs.append(_span(e))     # resolution link!
        elif isinstance(e, BinOp):
            self.expr(e.left); self.expr(e.right)
        elif isinstance(e, UnaryOp):
            self.expr(e.operand)
        # literals: nothing


def _span(node):
    return (node.span.line, node.span.col, node.span.end_col)

Test harness — ফাইলের শেষে:

def _test():
    from toylang.ast import NumLit, Span as Sp

    def P(*stmts): return Program(tuple(stmts))

    def let(n, v):
        return LetStmt(Sp(1, 1, 9), n, NumLit(Sp(1, 9, 9), v))

    # Test 1: clean program — zero errors + link built
    r = Resolver()
    r.resolve(P(let("x", 1),
                Print(Sp(2, 1, 10), VarRef(Sp(2, 7, 8), "x"))))
    assert r.errors == []
    assert r.links[(1, 1, 9)].refs == [(2, 7, 8)]

    # Test 2: undeclared + duplicate together, one run
    r = Resolver()
    r.resolve(P(
        let("a", 1),
        let("a", 2),                                    # duplicate
        Print(Sp(3, 1, 10), VarRef(Sp(3, 7, 8), "c"))   # undeclared
    ))
    msgs = [e.render() for e in r.errors]
    assert any("duplicate declaration" in m for m in msgs)
    assert any("undeclared name 'c'" in m for m in msgs)

    # Test 3: use-before-def violates single-pass rule
    r = Resolver()
    r.resolve(P(Print(Sp(1, 1, 10),
                      VarRef(Sp(1, 7, 8), "late")),
                let("late", 5)))
    assert any("undeclared" in e.msg for e in r.errors)

    # Test 4: shadowing across scopes is NOT an error
    r = Resolver()
    r.resolve(P(let("x", 1)))
    r._push()
    r._declare("x", (9, 1, 10))
    r._pop()
    assert not r.errors

    print("all resolver tests passed")

if __name__ == "__main__":
    _test()

Expected output:

$ python3 toylang/resolver.py
all resolver tests passed

আর একটা demo main যোগ করলে example section-এর program-টার exact error format দেখবেন:

demo = """
let a = 1;
{
  let b = a;
  print(c);
}
print(a);
"""

error[sem]: undeclared name 'c' @4:9-4:10

নিজে বাড়ান:

1. Unused-variable warning: যে Decl-এর refs empty — report (warning vs error decision document করুন)।
2. Two-pass mode flag: functions-এর জন্য collect-then-resolve — mutual recursion enable করুন।
3. Go-to-definition CLI: input file:line:col নিয়ে target decl-span print করুন — links map এখানেই কাজে লাগবে।