stmt

type ADTConstructor struct {
	TypeName string // The ADT type name (e.g., "Option")
	Tag      string // The variant tag (e.g., "Some")
	Args     []Expr // Constructor arguments
}

type ADTDecl struct {
	Variants []ADTVariant
}

type ADTVariant struct {
	Tag    string         // Constructor name (e.g., "Some", "None")
	Fields []ResolvedType // Field types (empty for nullary constructors)
}

type ArrayLit struct {
	ElemType ResolvedType
	Elems    []Expr
}

type AssignStmt struct {
	Name  string
	Value Expr
	Line  int // source line (0 = unknown)
}

type BinOp struct {
	Op    BinOpKind
	Left  Expr
	Right Expr
}

type BinOpKind int

type Binding struct {
	Name       string       // Variable name to bind
	FieldIndex int          // Which field of the variant (0-based)
	Type       ResolvedType // Type of the extracted field
}

type BuiltinCall struct {
	Name string // Builtin name (e.g., "_str_trim", "_list_map")
	Args []Expr
}

type Call struct {
	Func Expr   // The function to call (VarRef, GlobalRef, or Lambda)
	Args []Expr // Arguments
}

type Cons struct {
	Head Expr
	Tail Expr
}

type Expr interface {
	// contains filtered or unexported methods
}

type ExprStmt struct {
	Value Expr
	Line  int // source line (0 = unknown)
}

type FieldAccess struct {
	Record      Expr
	Field       string
	KnownFields []string
}

type FieldInit struct {
	Name  string
	Value Expr
}

type FuncDecl struct {
	Name       string       // Function name (already namespaced by module)
	Params     []Param      // Parameters
	ReturnType ResolvedType // Return type
	Body       []Stmt       // Function body statements
	Return     Expr         // Final return expression
	Exported   bool         // Whether this function is public
	Module     string       // Source module name
	File       string       // Source file path (for diagnostics; optional)
	Line       int          // Source line of the func declaration (for diagnostics; 0 = unknown)

	// LowerError is non-empty when the lower pass caught a panic or error
	// while lowering this function's body. The bytecode compiler will skip
	// normal compilation of such functions and mark the prototype as
	// EvalOnly with this reason, so the bridge dispatches the call to the
	// evaluator at runtime. Body/Return may be empty or partial in this
	// case — consumers should not traverse them.
	LowerError string
}

type FuncType struct {
	Params []ResolvedType
	Return ResolvedType
}

type GlobalRef struct {
	Module string // Source module
	Name   string // Function/value name
}

type IfExpr struct {
	Cond Expr
	Then Expr
	Else Expr
}

type IfStmt struct {
	Cond Expr
	Then []Stmt
	Else []Stmt // may be empty or contain another IfStmt for else-if chains
	Line int    // source line (0 = unknown)
}

type ImportSpec struct {
	Path  string // e.g., "strings", "fmt"
	Alias string // optional alias
}

type InterfaceType struct{}

type Lambda struct {
	Params []Param
	Body   []Stmt
	Return Expr
}

type ListLit struct {
	ElemType ResolvedType // Element type
	Elems    []Expr
}

type LitBool struct{ Value bool }

type LitFloat struct{ Value float64 }

type LitInt struct{ Value int64 }

type LitString struct{ Value string }

type LitUnit struct{}

type MapType struct{}

type NamedType struct {
	Name    string // Type name (e.g., "Color", "Position")
	Pointer bool   // Whether to use pointer semantics (true for ADTs)
}

type Param struct {
	Name string
	Type ResolvedType
}

type PrimitiveKind int

type PrimitiveType struct {
	Kind PrimitiveKind
}

type Program struct {
	Package   string       // Target package/module name
	TypeDecls []TypeDecl   // ADT and record type declarations
	FuncDecls []FuncDecl   // Function declarations
	Imports   []ImportSpec // Required imports (e.g., "fmt", "strings")
}

type RecordDecl struct {
	Fields []RecordField
}

type RecordField struct {
	Name string
	Type ResolvedType
}

type RecordLit struct {
	TypeName string // The record type name
	Fields   []FieldInit
}

type RecordUpdate struct {
	Base   Expr
	Fields []FieldInit
}

type ResolvedType interface {
	GoString() string // Go type representation (for the Go emitter)
	// contains filtered or unexported methods
}

type ReturnStmt struct {
	Value Expr
	Line  int // source line (0 = unknown)
}

type SliceType struct {
	Elem ResolvedType
}

type Stmt interface {
	// contains filtered or unexported methods
}

type SwitchCase struct {
	Tag      string    // ADT variant tag to match
	Bindings []Binding // Variables bound from the matched variant's fields
	Body     []Stmt
}

type SwitchStmt struct {
	Scrutinee Expr
	ADTName   string // The ADT type name (e.g., "Color") — helps emitters generate typed constants
	Cases     []SwitchCase
	Default   []Stmt // may be empty; if non-empty, must end in panic or return
	Line      int    // source line (0 = unknown)
}

type TupleLit struct {
	Elems []Expr
}

type TupleType struct {
	Elems []ResolvedType
}

type TypeAliasDecl struct {
	Target ResolvedType
}

type TypeAssert struct {
	Value Expr
	Type  ResolvedType
}

type TypeDecl struct {
	Name     string
	Kind     TypeDeclKind
	Exported bool
}

type TypeDeclKind interface {
	// contains filtered or unexported methods
}

type UnOp struct {
	Op      UnOpKind
	Operand Expr
}

type UnOpKind int

type VarDecl struct {
	Name  string
	Type  ResolvedType // may be nil if type is inferred
	Value Expr
	Line  int // source line (0 = unknown)
}

type VarRef struct{ Name string }