code

type AccessLevel int

type AggregateType Type

type BaseGenerator struct {
	// contains filtered or unexported fields
}

type BinaryOperator Operator

type BooleanOperator Operator

type Expr struct {
	Op   Operator
	Val1 *Val
	Val2 union.Maybe[*Val]
	Val3 union.Maybe[*Val]
}

type FuncDef struct {
	Access  AccessLevel    // The level of access
	Params  map[string]Val // Parameters of function
	Locals  map[string]Val // Local constants and vars
	Results []TypeDef      // Results of function

}

type Generator interface {
	// Return the base path to generate dirs under
	GetBasePath() string
	// Set the base path once to generate dirs under. Setting again panics.
	SetBasePath(basePath string) Generator
	// Creates a directory, or wipes out the contents (assuming they are from a prior run of the same generator).
	// The caller must generate parent directories before child directories, or a panic occurs.
	// This will be the current directory until another call is made
	Dir(name string) Generator
	// Creates a src file in the current directory
	// This will be the current source file under another call is made
	Src(name string) Generator
	// Create global constants in the current source file
	GlobalConsts(constants ...Val) Generator
	// Create global vars in the current source file
	GlobalVars(globals ...Val) Generator
	// Create types in the current source file
	Types(objects ...ObjectDef) Generator
	// Create funcs in the current source file
	Funcs(funcs ...FuncDef) Generator
}

type ObjectDef struct {
	TypeDef TypeDef            // Name of the object type, and any generics
	Fields  map[string]TypeDef // Object fields
	Funcs   map[string]FuncDef // Object methods
}

type Operator uint

type PkgDef struct {
	Path    string   // Relative path to dir containing sources
	Sources []SrcDef // Source files

	// Init is an optional initialization function for the package.
	// The set of all package init functions execute in some arbitrary order at runtime.
	// Depending on the target language, they may all execute before main starts, or they may execute some time later.
	// such as when files that need them are loaded.
	Init union.Maybe[FuncDef]
}

type ScalarType Type

type SrcDef struct {
	Globals map[string]TypeDef   // Global constants and vars
	Objects map[string]ObjectDef // Objects
	Funcs   map[string]FuncDef   // Top level functions that are not methods
	Main    FuncDef              // Main function
}

type StmtDef struct {
	Kind StmtKind              // The kind of statement
	Type union.Maybe[*TypeDef] // The TypeDef for a Constant or Local
	Expr union.Maybe[*Expr]    // The Value to assign a Constant or Local
}

type StmtKind uint

type Type uint

type TypeDef struct {
	Access      AccessLevel // Level of access, if applicable. Empty means default level.
	Typ         Type        // Type
	ArrayBounds []uint      // Bounds of an array. A dimension can be -1 for unspecified dimension, slice can
	// be zero length for one unspecified dimension.
	// For a list, one element >= 1 that indicates list, or list of list, etc.
	Name      string                // Name of an enum or object
	Names     []string              // Names of enum constants or object generics - zero-based indexes are the enum values, strings are the names
	KeyType   union.Maybe[*TypeDef] // Map key type
	ValueType union.Maybe[*TypeDef] // Array element type, Enum base type, list element type, map value type, maybe type, object base type, or set element type
}

type Types interface {
	Type | ScalarType | AggregateType
}

type UnaryOperator Operator

type Val struct {
	Access union.Maybe[AccessLevel] // Level of access
	Kind   ValKind                  // The kind of value
	Typ    *TypeDef                 // The TypeDef
	Value  string                   // The literal value or variable name
}

type ValKind int