bbq

type CodePrinter[T, E any] func(
	builder *strings.Builder,
	code []E,
	resolve bool,
	constants []constant.DecodedConstant,
	types []T,
	functionNames []string,
	colorize bool,
) error

type Contract struct {
	Name     string
	Location common.Location
}

type ContractGlobal struct {
	GlobalInfo
	Contract *Contract
}

type Function[E any] struct {
	Name               string
	QualifiedName      string
	Code               []E
	ParameterCount     uint16
	TypeParameterCount uint16
	LocalCount         uint16
	TypeIndex          uint16
	LineNumbers        LineNumberTable
}

type FunctionGlobal[E any] struct {
	GlobalInfo
	Function *Function[E]
}

type Global interface {
	GetGlobalInfo() GlobalInfo
}

type GlobalInfo struct {
	Name string
	// Need to maintain both "qualified" and "unqualified" names for a global,
	// because when type-aliasing is used, imported global name becomes qualified.
	// However, the same imported-global must use the unqualified name when linking.
	// TODO: We can simplify this by always using qualified names for all imports.
	QualifiedName string
	Location      common.Location
	Index         uint16
}

type GlobalKind int

type Import struct {
	Location common.Location
	Name     string
}

type ImportedGlobal struct {
	GlobalInfo
}

type InstructionProgram = Program[opcode.Instruction, StaticType]

type LineNumberTable struct {
	Positions []PositionInfo
}

type Position struct {
	StartPos ast.Position
	EndPos   ast.Position
}

type PositionInfo struct {
	InstructionIndex uint16
	Position         Position
}

type Program[E, T any] struct {
	Contracts []*Contract
	Imports   []Import
	Functions []Function[E]
	Constants []constant.DecodedConstant
	Variables []Variable[E]
	Types     []T
	Globals   []Global
}

type ProgramPrinter[E, T any] struct {
	// contains filtered or unexported fields
}

type StaticType = interpreter.StaticType

type TypeDecoder[T any] func(bytes T) (StaticType, error)

type Variable[E any] struct {
	Name   string
	Getter *Function[E]
}

type VariableGlobal[E any] struct {
	GlobalInfo
	Variable *Variable[E]
}