AST Design — tree-টা নিজেই একটা data structure design সমস্যা

toylang/ast.py — self-contained (parser integration optional):

"""ToyLang AST: node definitions + pretty-printer."""
from dataclasses import dataclass, field


@dataclass(frozen=True)
class Span:
    line: int
    col: int
    end_col: int

    def show(self):
        return f"{self.line}:{self.col}-{self.end_col}"


# ---------------- expressions ----------------
@dataclass(frozen=True)
class Expr:
    span: Span

@dataclass(frozen=True)
class NumLit(Expr):
    value: int

@dataclass(frozen=True)
class StrLit(Expr):
    value: str

@dataclass(frozen=True)
class BoolLit(Expr):
    value: bool

@dataclass(frozen=True)
class VarRef(Expr):
    name: str

@dataclass(frozen=True)
class UnaryOp(Expr):
    op: str          # "neg" | "not"
    operand: Expr

@dataclass(frozen=True)
class BinOp(Expr):
    op: str
    left: Expr
    right: Expr


BP = {"oror": 10, "andand": 20, "eqeq": 40, "bangeq": 40,
      "lte": 50, "gte": 50, "lt": 50, "gt": 50,
      "plus": 60, "minus": 60, "star": 70, "slash": 70}
SYM = {"plus": "+", "minus": "-", "star": "*", "slash": "/",
       "eqeq": "==", "bangeq": "!=", "lt": "\<", "gt": ">",
       "lte": "\<=", "gte": ">=", "andand": "&&", "oror": "||"}


# ---------------- statements ----------------
@dataclass(frozen=True)
class Stmt:
    span: Span

@dataclass(frozen=True)
class LetStmt(Stmt):
    name: str
    init: Expr

@dataclass(frozen=True)
class Print(Stmt):
    arg: Expr

@dataclass(frozen=True)
class IfStmt(Stmt):
    cond: Expr
    then: tuple
    else_: tuple | None

@dataclass(frozen=True)
class WhileStmt(Stmt):
    cond: Expr
    body: tuple

@dataclass(frozen=True)
class ExprStmt(Stmt):
    expr: Expr

@dataclass(frozen=True)
class Program:
    stmts: tuple


def _bp(e: Expr) -> int:
    return BP.get(e.op, 99) if isinstance(e, BinOp) else 99


class Printer:
    """AST -> canonical ToyLang source."""

    def expr(self, e: Expr, parent_bp: int = 0) -> str:
        m = {
            NumLit: lambda n: str(n.value),
            StrLit: lambda n: f'"{n.value}"',
            BoolLit: lambda n: "true" if n.value else "false",
            VarRef: lambda n: n.name,
            UnaryOp: lambda n: ("-" if n.op == "neg" else "!") +
                               self.expr(n.operand, 90),
            BinOp: lambda n: self._bin(n),
        }
        return m[type(e)](e)

    def _bin(self, n: BinOp) -> str:
        my = BP[n.op]
        l = self.expr(n.left, my)
        r = self.expr(n.right, my + 1)   # right child tighter!
        s = f"{l} {SYM[n.op]} {r}"
        return f"({s})" if my \< parent_bp else s

    def stmt(self, s: Stmt, ind: str = "") -> str:
        if isinstance(s, LetStmt):
            return f"{ind}let {s.name} = {self.expr(s.init)};"
        if isinstance(s, Print):
            return f"{ind}print({self.expr(s.arg)});"
        if isinstance(s, ExprStmt):
            return f"{ind}{self.expr(s.expr)};"
        if isinstance(s, IfStmt):
            out = [f"{ind}if ({self.expr(s.cond)}) {{"]
            out += [self.stmt(x, ind + "    ") for x in s.then]
            out.append(f"{ind}}}")
            if s.else_ is not None:
                out[-1] += " else {"
                out += [self.stmt(x, ind + "    ") for x in s.else_]
                out.append(f"{ind}}}")
            return "\n".join(out)
        if isinstance(s, WhileStmt):
            out = [f"{ind}while ({self.expr(s.cond)}) {{"]
            out += [self.stmt(x, ind + "    ") for x in s.body]
            out.append(f"{ind}}}")
            return "\n".join(out)
        raise TypeError(type(s))

    def program(self, p: Program) -> str:
        return "\n".join(self.stmt(s) for s in p.stmts)


def pretty(node) -> str:
    if isinstance(node, Program):
        return Printer().program(node)
    if isinstance(node, Stmt):
        return Printer().stmt(node)
    return Printer().expr(node)

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

def _test():
    S = Span
    # hand-built: let x = 1 + 2 * 3;
    prog = Program((LetStmt(S(1, 1, 20), "x",
                   BinOp(S(1, 11, 19), "plus", NumLit(S(1, 9, 9), 1),
                   BinOp(S(1, 15, 19), "star",
                         NumLit(S(1, 13, 13), 2),
                         NumLit(S(1, 17, 19), 3)))),))
    assert pretty(prog) == "let x = 1 + 2 * 3;"

    # parens needed when child binds looser:
    grouped = BinOp(S(1, 1, 12), "star",
                    BinOp(S(1, 2, 7), "plus",
                          NumLit(S(1, 3, 3), 1),
                          NumLit(S(1, 6, 6), 2)),
                    NumLit(S(1, 11, 11), 3))
    assert pretty(grouped) == "(1 + 2) * 3"

    # unary chains:
    assert pretty(UnaryOp(S(1, 1, 4), "not",
                  BoolLit(S(1, 4, 7), False))) == "!false"

    # if/else round-trip shape:
    iff = IfStmt(S(1, 1, 40), VarRef(S(1, 5, 5), "ok"),
                 (Print(S(2, 5, 14), NumLit(S(2, 11, 11), 1)),),
                 (Print(S(4, 5, 14), NumLit(S(4, 11, 11), 0)),))
    want = ("if (ok) {\n    print(1);\n} else {\n    print(0);\n}")
    assert pretty(iff) == want

    print("all AST tests passed")

if __name__ == "__main__":
    _test()

Expected:

$ python3 toylang/ast.py
all AST tests passed

Round-trip contract-টা এখন mechanical: pretty(parse(src)) re-parse করে same AST দেয় — পরের লেসনে parser-কে এই nodes return করতে wire করলেই property test হয়ে যাবে: assert pretty(Parser(src).program()) == pretty(Parser(pretty(...)).program())।

নিজে বাড়ান:

1. Parser (lesson 4)-কে wire করুন — tuples-এর বদলে এই dataclasses return করুন; lexer positions থেকে span fill করুন।
2. size(Program) walker লিখুন switch-style — node-count report.
3. find_spans(program, line) — specific line-এর সব node return; IDE hover-এর mini-simulation।