Compile to Bytecode v4

hard · compilers, bytecode, lowering, control flow

Compile to Bytecode v4

Lower a v4 Program AST into stack-based bytecode with loops and short-circuit logic.

Function signature

func Compile(prog *Program) Bytecode

Bytecode types

Use the provided types:

Bytecode with Main []Instr and Functions []Function
Function with ID, Name, Params, and Code []Instr
Instr with Op, Int, and Str

Instruction rules

This builds on v3 (closures, arrays, maps, indexing) and adds:

for loop

ENTER_SCOPE
init
loopStart:
cond (or PUSH_BOOL 1 if omitted)
JUMP_IF_FALSE end
body
post
JUMP loopStart
end:
EXIT_SCOPE

break / continue

break emits a jump patched to loop end.
continue emits a jump patched to the loop's continue target.

logical operators

&& and || must short-circuit and return a boolean.
Implement using jumps + PUSH_BOOL + POP (no new opcodes).

Notes

Assume the AST is already valid.
Keep the compiler readable and straightforward.

Before implementation

Use the module’s worked reconstruction and independent debugging lab to predict an intermediate artifact first. Preserve one failing counterexample while implementing the stated API. The lesson’s transfer task uses a fresh case after the guided trace.

package solution

type VarKind int

const (
	VarLet VarKind = iota
	VarVar
	VarConst
)

type StmtKind int

const (
	StmtVar StmtKind = iota
	StmtAssign
	StmtExpr
	StmtIf
	StmtWhile
	StmtFor
	StmtBreak
	StmtContinue
	StmtReturn
	StmtBlock
	StmtFn
)

type Stmt struct {
	Kind    StmtKind
	VarKind VarKind
	Name    string
	Expr    *Expr
	Target  *Expr
	Body    []*Stmt
	Else    []*Stmt
	Params  []string
	Init    *Stmt
	Post    *Stmt
	Cond    *Expr
}

type Program struct {
	Stmts []*Stmt
}

type ExprKind int

const (
	ExprNumber ExprKind = iota
	ExprString
	ExprBool
	ExprNil
	ExprIdent
	ExprUnary
	ExprBinary
	ExprCall
	ExprArray
	ExprMap
	ExprIndex
)

type MapPair struct {
	Key   *Expr
	Value *Expr
}

type Expr struct {
	Kind  ExprKind
	Value string
	Left  *Expr
	Right *Expr
	Args  []*Expr
	Elems []*Expr
	Pairs []MapPair
}

type OpCode int

const (
	OpPushNum OpCode = iota
	OpPushStr
	OpPushBool
	OpPushNil
	OpLoad
	OpStore
	OpDefineVar
	OpDefineConst
	OpAdd
	OpSub
	OpMul
	OpDiv
	OpNeg
	OpNot
	OpEq
	OpNeq
	OpLt
	OpLte
	OpGt
	OpGte
	OpJump
	OpJumpIfFalse
	OpCall
	OpReturn
	OpEnterScope
	OpExitScope
	OpPop
	OpMakeClosure
	OpMakeArray
	OpMakeMap
	OpGetIndex
	OpSetIndex
)

type Instr struct {
	Op  OpCode
	Int int
	Str string
}

type Function struct {
	ID     int
	Name   string
	Params []string
	Code   []Instr
}

type Bytecode struct {
	Functions []Function
	Main      []Instr
}

// Compile lowers a program AST into bytecode.
func Compile(prog *Program) Bytecode {
	// TODO: implement the compiler.
	return Bytecode{}
}