ast_nodes.py

"""
voidc.ast_nodes
===============
Stage 3: the Abstract Syntax Tree produced by the Parser and consumed by
the Semantic Analyzer / Type Checker / IR lowering pass.

Every node is a plain dataclass (cheap to construct, easy to pattern
match on `type(node)` inside visitors). `Node.line`/`col` are populated
by the parser for diagnostics.

The tree is intentionally "concrete-ish" (close to source grammar)
rather than fully desugared; desugaring (e.g. `foreach` -> `while` +
iterator protocol, `for` C-style -> `while`) happens in the IR lowering
stage (ir.py) so the semantic analyzer can still give feature-specific
error messages ("foreach requires an iterable", etc).
"""

from dataclasses import dataclass, field
from typing import List, Optional, Any


@dataclass
class Node:
    line: int = field(default=0, kw_only=True)
    col: int = field(default=0, kw_only=True)


# ---------------------------------------------------------------- types
@dataclass
class TypeExpr(Node):
    """A syntactic type: `int`, `string`, `[]int`, `Map<string, int>`,
    `T`, `Option<T>`, `&T`, `*T`, `fn(int) -> bool` ..."""
    name: str = ""
    args: List["TypeExpr"] = field(default_factory=list)   # generic args
    is_ref: bool = False       # &T
    is_ptr: bool = False       # *T
    is_array: bool = False     # []T  (dynamic array / slice)
    array_size: Optional[int] = None  # [N]T fixed size array
    is_optional: bool = False  # T?
    fn_params: Optional[List["TypeExpr"]] = None  # for fn(...)->T types
    fn_return: Optional["TypeExpr"] = None

    def __str__(self):
        s = self.name
        if self.args:
            s += "<" + ", ".join(str(a) for a in self.args) + ">"
        if self.is_array:
            s = f"[{self.array_size if self.array_size is not None else ''}]" + s
        if self.is_ref:
            s = "&" + s
        if self.is_ptr:
            s = "*" + s
        if self.is_optional:
            s = s + "?"
        return s


# ------------------------------------------------------------ expressions
@dataclass
class Expr(Node):
    pass


@dataclass
class IntLit(Expr):
    value: int = 0
    suffix: str = ""


@dataclass
class FloatLit(Expr):
    value: float = 0.0
    suffix: str = ""


@dataclass
class BoolLit(Expr):
    value: bool = False


@dataclass
class StringLit(Expr):
    value: str = ""


@dataclass
class CharLit(Expr):
    value: str = ""


@dataclass
class NullLit(Expr):
    pass


@dataclass
class Ident(Expr):
    name: str = ""
    type_args: List[TypeExpr] = field(default_factory=list)  # explicit generic args: name<T,U>(...)



@dataclass
class BinOp(Expr):
    op: str = ""
    left: Expr = None
    right: Expr = None


@dataclass
class UnaryOp(Expr):
    op: str = ""
    operand: Expr = None
    postfix: bool = False


@dataclass
class Assign(Expr):
    op: str = "="   # =, +=, -=, ...
    target: Expr = None
    value: Expr = None


@dataclass
class Ternary(Expr):
    cond: Expr = None
    then_expr: Expr = None
    else_expr: Expr = None


@dataclass
class Call(Expr):
    callee: Expr = None
    args: List[Expr] = field(default_factory=list)
    named_args: dict = field(default_factory=dict)   # name -> Expr
    type_args: List[TypeExpr] = field(default_factory=list)


@dataclass
class Index(Expr):
    obj: Expr = None
    index: Expr = None


@dataclass
class Field(Expr):
    obj: Expr = None
    name: str = ""


@dataclass
class ArrayLit(Expr):
    elements: List[Expr] = field(default_factory=list)


@dataclass
class TupleLit(Expr):
    elements: List[Expr] = field(default_factory=list)


@dataclass
class MapLit(Expr):
    keys: List[Expr] = field(default_factory=list)
    values: List[Expr] = field(default_factory=list)


@dataclass
class StructLit(Expr):
    type_name: str = ""
    fields: dict = field(default_factory=dict)  # name -> Expr
    type_args: List[TypeExpr] = field(default_factory=list)


@dataclass
class Lambda(Expr):
    """Anonymous function / closure literal: `fn(x: int) -> int => x * 2`"""
    params: List["Param"] = field(default_factory=list)
    return_type: Optional[TypeExpr] = None
    body: Any = None            # Block or single Expr
    captures: List[str] = field(default_factory=list)  # filled by semantic analysis


@dataclass
class CastExpr(Expr):
    value: Expr = None
    target: TypeExpr = None


@dataclass
class RefExpr(Expr):
    value: Expr = None


@dataclass
class DerefExpr(Expr):
    value: Expr = None


@dataclass
class MatchArm(Node):
    pattern: Any = None   # Expr | "Pattern" (Ident for bindings, EnumPattern, WildcardPattern)
    guard: Optional[Expr] = None
    body: Any = None       # Block or Expr


@dataclass
class WildcardPattern(Node):
    pass


@dataclass
class EnumPattern(Node):
    enum_name: str = ""
    variant: str = ""
    bindings: List[str] = field(default_factory=list)


@dataclass
class MatchExpr(Expr):
    subject: Expr = None
    arms: List[MatchArm] = field(default_factory=list)


# ------------------------------------------------------------- statements
@dataclass
class Stmt(Node):
    pass


@dataclass
class Block(Stmt):
    stmts: List[Stmt] = field(default_factory=list)


@dataclass
class Param(Node):
    name: str = ""
    type: Optional[TypeExpr] = None
    default: Optional[Expr] = None
    is_named: bool = False


@dataclass
class VarDecl(Stmt):
    name: str = ""
    type: Optional[TypeExpr] = None
    value: Optional[Expr] = None
    is_const: bool = False
    is_mut: bool = False


@dataclass
class ExprStmt(Stmt):
    expr: Expr = None


@dataclass
class ReturnStmt(Stmt):
    value: Optional[Expr] = None


@dataclass
class BreakStmt(Stmt):
    label: Optional[str] = None


@dataclass
class ContinueStmt(Stmt):
    label: Optional[str] = None


@dataclass
class IfStmt(Stmt):
    cond: Expr = None
    then_branch: Block = None
    else_branch: Any = None   # Block | IfStmt | None


@dataclass
class WhileStmt(Stmt):
    cond: Expr = None
    body: Block = None
    label: Optional[str] = None


@dataclass
class DoWhileStmt(Stmt):
    body: Block = None
    cond: Expr = None


@dataclass
class ForStmt(Stmt):
    """C-style: for (init; cond; step) { }"""
    init: Optional[Stmt] = None
    cond: Optional[Expr] = None
    step: Optional[Stmt] = None
    body: Block = None
    label: Optional[str] = None


@dataclass
class ForeachStmt(Stmt):
    var_name: str = ""
    index_name: Optional[str] = None
    iterable: Expr = None
    body: Block = None
    label: Optional[str] = None


@dataclass
class SwitchCase(Node):
    values: List[Expr] = field(default_factory=list)  # empty => default
    body: Block = None
    fallthrough: bool = False


@dataclass
class SwitchStmt(Stmt):
    subject: Expr = None
    cases: List[SwitchCase] = field(default_factory=list)


# ------------------------------------------------------------- declarations
@dataclass
class GenericParam(Node):
    name: str = ""
    bound: Optional[str] = None   # trait bound, e.g. T: Comparable


@dataclass
class FnDecl(Stmt):
    name: str = ""
    params: List[Param] = field(default_factory=list)
    return_type: Optional[TypeExpr] = None
    body: Optional[Block] = None
    generics: List[GenericParam] = field(default_factory=list)
    visibility: str = "private"   # public | private
    is_static: bool = False
    is_virtual: bool = False
    is_override: bool = False
    is_abstract: bool = False
    attributes: List[str] = field(default_factory=list)
    owner: Optional[str] = None   # class/struct name if this is a method


@dataclass
class FieldDecl(Node):
    name: str = ""
    type: TypeExpr = None
    default: Optional[Expr] = None
    visibility: str = "public"
    is_static: bool = False


@dataclass
class StructDecl(Stmt):
    name: str = ""
    fields: List[FieldDecl] = field(default_factory=list)
    generics: List[GenericParam] = field(default_factory=list)
    methods: List[FnDecl] = field(default_factory=list)
    implements: List[str] = field(default_factory=list)  # trait names
    visibility: str = "public"


@dataclass
class ClassDecl(Stmt):
    name: str = ""
    fields: List[FieldDecl] = field(default_factory=list)
    methods: List[FnDecl] = field(default_factory=list)
    constructors: List[FnDecl] = field(default_factory=list)
    destructor: Optional[FnDecl] = None
    generics: List[GenericParam] = field(default_factory=list)
    base: Optional[str] = None          # single inheritance
    implements: List[str] = field(default_factory=list)  # interfaces
    is_abstract: bool = False
    visibility: str = "public"


@dataclass
class EnumVariant(Node):
    name: str = ""
    fields: List[TypeExpr] = field(default_factory=list)   # tuple-like payload
    value: Optional[int] = None   # explicit discriminant for C-like enums


@dataclass
class EnumDecl(Stmt):
    name: str = ""
    variants: List[EnumVariant] = field(default_factory=list)
    generics: List[GenericParam] = field(default_factory=list)
    visibility: str = "public"


@dataclass
class UnionDecl(Stmt):
    name: str = ""
    fields: List[FieldDecl] = field(default_factory=list)
    visibility: str = "public"


@dataclass
class TraitMethodSig(Node):
    name: str = ""
    params: List[Param] = field(default_factory=list)
    return_type: Optional[TypeExpr] = None
    default_body: Optional[Block] = None


@dataclass
class TraitDecl(Stmt):
    name: str = ""
    methods: List[TraitMethodSig] = field(default_factory=list)
    visibility: str = "public"


@dataclass
class ImplBlock(Stmt):
    trait_name: Optional[str] = None
    type_name: str = ""
    methods: List[FnDecl] = field(default_factory=list)


@dataclass
class ImportDecl(Stmt):
    path: str = ""              # "std::io" or "./mymodule"
    alias: Optional[str] = None
    names: List[str] = field(default_factory=list)  # `import { a, b } from "mod"`


@dataclass
class ModuleDecl(Stmt):
    name: str = ""
    body: List[Stmt] = field(default_factory=list)


@dataclass
class ExportStmt(Stmt):
    inner: Stmt = None


@dataclass
class Program(Node):
    imports: List[ImportDecl] = field(default_factory=list)
    decls: List[Stmt] = field(default_factory=list)