Compile to Bytecode v5

hard · compilers, bytecode, modules

Compile to Bytecode v5

Lower v5 modules into stack-based bytecode with module initialization and export maps.

Function signature

func CompileModules(prog *Program) []ModuleBytecode

Types

Use the provided types:

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

Module initialization

Each module compiles to init code:

ENTER_SCOPE
(import aliases)
(module statements)
PUSH_STR "exportName"
LOAD exportName
MAKE_MAP N
EXIT_SCOPE
DEFINE_CONST moduleName

Imports

For each import X as Y emit:

LOAD X
DEFINE_CONST Y

Member access

m.add compiles to:

LOAD m
PUSH_STR "add"
GET_INDEX

Notes

Assume the AST is already valid.
Preserve module order from the program.
Exports should list exported names in the order discovered.
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
	Exported bool
	VarKind  VarKind
	Name     string
	Expr     *Expr
	Target   *Expr
	Body     []*Stmt
	Else     []*Stmt
	Params   []string
	Init     *Stmt
	Post     *Stmt
	Cond     *Expr
}

type Program struct {
	Modules []*Module
}

type Module struct {
	Name    string
	Imports []Import
	Stmts   []*Stmt
}

type Import struct {
	Name  string
	Alias string
}

type ExprKind int

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

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
}

type ModuleBytecode struct {
	Name     string
	Imports  []Import
	Exports  []string
	Bytecode Bytecode
}

// CompileModules lowers a program AST into module bytecode.
func CompileModules(prog *Program) []ModuleBytecode {
	// TODO: implement module compilation.
	return nil
}