ir

type BinOp uint

type BinOpExpr struct {
	Left  Expr
	Right Expr
	Op    BinOp
}

type Block struct {
	Stmts []Stmt
}

type Branch struct {
	Index uint32
}

type BranchIf struct {
	Exp   Expr
	Index uint32
}

type Call struct {
	Arguments     []Expr
	FunctionIndex uint32
}

type Const struct {
	Constant Constant
}

type ConstVisitor interface {
	VisitInt(Int) Repr
	VisitString(String) Repr
}

type Constant interface {
	Accept(Visitor) Repr
	// contains filtered or unexported methods
}

type CopyLocal struct {
	LocalIndex uint32
}

type Drop struct {
	Exp Expr
}

type Expr interface {
	Accept(Visitor) Repr
	// contains filtered or unexported methods
}

type ExprVisitor interface {
	VisitConst(*Const) Repr
	VisitCopyLocal(*CopyLocal) Repr
	VisitMoveLocal(*MoveLocal) Repr
	VisitUnOpExpr(*UnOpExpr) Repr
	VisitBinOpExpr(*BinOpExpr) Repr
	VisitCall(*Call) Repr
}

type Func struct {
	Statement Stmt
	Name      string
	Type      FuncType
	Locals    []Local
}

type FuncType struct {
	Params  []ValType
	Results []ValType
}

type If struct {
	Test Expr
	Then Stmt
	Else Stmt
}

type Int struct {
	Value []byte
}

type Local struct {
	Type ValType
}

type Loop struct {
	Stmts []Stmt
}

type MoveLocal struct {
	LocalIndex uint32
}

type Repr any

type Return struct {
	Exp Expr
}

type Sequence struct {
	Stmts []Stmt
}

type Stmt interface {
	Accept(Visitor) Repr
	// contains filtered or unexported methods
}

type StmtVisitor interface {
	VisitSequence(*Sequence) Repr
	VisitBlock(*Block) Repr
	VisitLoop(*Loop) Repr
	VisitIf(*If) Repr
	VisitBranch(*Branch) Repr
	VisitBranchIf(*BranchIf) Repr
	VisitStoreLocal(*StoreLocal) Repr
	VisitDrop(*Drop) Repr
	VisitReturn(*Return) Repr
}

type StoreLocal struct {
	Exp        Expr
	LocalIndex uint32
}

type String struct {
	Value string
}

type UnOp uint

type UnOpExpr struct {
	Expr Expr
	Op   UnOp
}

type ValType uint

type Visitor interface {
	ConstVisitor
	StmtVisitor
	ExprVisitor
	VisitFunc(f *Func) Repr
}