Token stream into an AST. Recursive descent, precedence climbing for expressions.

Statement nodes:

{:func, name, params, body, line}
{:var, name, expr, line}          # var x = expr  (declares)
{:assign, target, op, expr, line} # x = expr / x += expr
{:if, [{cond, body}, ...], else_body, line}
{:match, subject, [{patterns, body}, ...], line}
{:for, var, collection, body, line}
{:while, condition, body, line}
{:break, line}
{:continue, line}
{:return, expr | nil, line}
{:expr, expr, line}
{:pass, line}

Expression nodes:

{:int | :float | :string | :bool, value, line}
{:null, line}
{:ident, name, line}
{:binop, op, lhs, rhs, line}
{:unop, op, operand, line}
{:call, callee, args, line}
{:ternary, condition, then_expr, else_expr, line}
{:enum, name | nil, [{member, value}], line}
{:signal, name, line}
{:class, name, parent | nil, body, line}
{:class_name, name, line}
{:lambda, params, body, line}
{:await, expr, line}
{:member, object, field, line}
{:index, object, index, line}
{:array, elements, line}
{:dict, [{key, value}], line}

if keeps its elif chain as a flat clause list rather than nesting, so codegen can compute one assigned-variable set across every branch.