ast

type Annotation struct {
	Raw        string // original casing as written in source
	Normalized string // canonical lowercase form for comparisons
	Known      bool   // true if the annotation is registered in the runtime
}

type ArrayLit struct{ Elems []Expr }

type AssignStmt struct {
	Target Expr     // left side of assignment (could be identifier or field access)
	Value  Expr     // right side of assignment
	Pos    Position // position of the assignment operator
}

type BinaryExpr struct {
	Op       int
	Lhs, Rhs Expr
}

type BoolLit struct{ Value bool }

type BreakStmt struct{}

type BytesLit struct{ Value []byte }

type CallExpr struct {
	Callee Expr
	Args   []Expr
}

type CatchClause struct {
	VarName    string // variable name to bind the exception
	Modifier   string // modifier like "final", "const"
	ExceptType string // type of exception to catch (optional)
	Body       []Stmt
}

type ChannelExpr struct {
	ElemType string // Type of elements in the channel
}

type ClassDecl struct {
	Name             string
	Parent           string           // parent class name for inheritance
	ParentTypeParams []TypeParam      // parent's generic type parameters (e.g., Container<T> has [T])
	Implements       []string         // interface names
	IsAbstract       bool             // whether the class is abstract
	AccessLevel      string           // "public", "private", "protected"
	IsSealed         bool             // whether the class is sealed
	Permits          []string         // names permitted to inherit
	Fields           []FieldDecl      // class fields
	Methods          []MethodDecl     // class methods
	Constructor      *ConstructorDecl // class constructor
	TypeParams       []TypeParam      // generic type parameters (e.g., [T, K, V])
}

type ConstructorDecl struct {
	Params []Parameter
	Body   []Stmt
}

type ContinueStmt struct{}

type DefStmt struct {
	Name        string
	Params      []Parameter // updated to support typed and variadic parameters
	Body        []Stmt
	ReturnType  *Type       // Return type using unified type system
	AccessLevel string      // "public", "private", "protected"
	Modifiers   []string    // all modifiers including access level
	TypeParams  []TypeParam // generic type parameters (e.g., [T, K, V])
}

type DeferStmt struct {
	Call Expr
	Pos  Position
}

type DoLoopStmt struct {
	Condition Expr // required: loop condition
	Body      []Stmt
}

type EnumDecl struct {
	Name        string
	AccessLevel string // "public", "private", "protected"
	IsSealed    bool
	Permits     []string
	Values      []EnumValue
	Fields      []FieldDecl      // enum can have fields
	Methods     []MethodDecl     // enum can have methods
	Constructor *ConstructorDecl // enum constructor
}

type EnumValue struct {
	Name string
	Args []Expr // constructor arguments
}

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

type ExprStmt struct{ X Expr }

type FieldDecl struct {
	Name      string
	Type      *Type    // Type annotation using unified type system
	Modifiers []string // public, private, protected, static, final
	InitValue Expr     // optional initial value
}

type FieldExpr struct {
	X    Expr
	Name string
}

type ForInStmt struct {
	Name     string   // deprecated: use Names for single or multiple vars
	Names    []string // iteration variable names (supports destructuring)
	Iterable Expr
	Where    Expr // optional where clause for filtering
	Body     []Stmt
}

type GenericCallExpr struct {
	Name       string      // Base type name (e.g., "List", "Set", "Map", "Lambda")
	TypeParams []TypeParam // Type parameters (e.g., [TypeParam{Name: "Int"}] for List<Int>)
	Args       []Expr      // Constructor arguments
}

type Ident struct {
	Name string
}

type IfClause struct {
	Cond Expr
	Body []Stmt
}

type IfStmt struct {
	Clauses []IfClause
	Else    []Stmt
}

type ImportStmt struct {
	Path  []string // e.g., ["math","vector"]
	Names []string // specific symbols to import; if empty, import as namespace (future)
}

type IndexExpr struct {
	X     Expr
	Index Expr
}

type InstanceOfExpr struct {
	Expr     Expr   // the object to check
	TypeName string // the type to check against
	Variable string // optional variable to assign (e.g., "foo" in "10 instanceof int final foo")
	Modifier string // optional modifier like "final"
}

type InterfaceDecl struct {
	Name        string
	Methods     []MethodSignature
	TypeParams  []TypeParam // generic type parameters (e.g., [T, K, V])
	IsSealed    bool        // whether the interface is sealed
	Permits     []string    // names permitted to implement
	Fields      []FieldDecl // static fields
	AccessLevel string      // "public", "private", "protected"
}

type InterpolatedStringLit struct {
	Parts []Expr // alternating string literals and expressions
}

type LambdaExpr struct {
	Params     []Parameter // updated to support typed and variadic parameters
	Body       Expr        // expression body (single expression)
	BlockBody  []Stmt      // statement block body (multi-line lambda with do...end)
	ReturnType *Type       // Return type using unified type system
	IsBlock    bool        // true if this is a multi-line lambda
}

type LetStmt struct {
	Name      string   // Single variable name (for backward compatibility)
	Names     []string // Multiple variable names for destructuring (e.g., let a, b = [1,2])
	Value     Expr
	Type      *Type    // Type annotation using unified type system
	Modifiers []string // optional modifiers: public/private/protected/static
	Kind      string   // "let", "var", "const", "final"
	Inferred  bool     // true if declared with ':=' (type inference)
}

type LoopStmt struct {
	Condition Expr // optional: if nil, infinite loop
	Body      []Stmt
}

type MapEntry struct {
	Key   any
	Value any
}

type MapLit struct{ Pairs []MapPair }

type MapPair struct {
	Key   string
	Value Expr
}

type MethodDecl struct {
	Name        string
	Params      []Parameter
	ReturnType  *Type // Return type using unified type system
	Body        []Stmt
	Modifiers   []string // public, private, protected, static, abstract, final
	IsAbstract  bool
	IsOverride  bool         // whether this method is marked with @override
	Annotations []Annotation // annotations like @override, @deprecated, etc.
}

type MethodSignature struct {
	Name        string
	Params      []Parameter
	ReturnType  *Type  // Return type using unified type system
	HasDefault  bool   // whether this method has a default implementation
	DefaultBody []Stmt // default implementation body
}

type NilLit struct{}

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

type NumberLit struct{ Value any } // Can be int or float64

type Parameter struct {
	Name       string
	Type       *Type // Type annotation using unified type system
	IsVariadic bool  // true if this parameter is variadic (args...)
}

type Position struct {
	Offset int // 0-based byte offset
	Line   int // 1-based line number
	Col    int // 1-based column number (in runes)
}

type Program struct {
	Stmts []Stmt
}

type RangeExpr struct {
	Start     Expr
	End       Expr
	Inclusive bool // true for ..., false for ..
}

type RecordComponent struct {
	Name string
	Type *Type // Type annotation using unified type system
}

type RecordDecl struct {
	Name        string
	AccessLevel string            // "public", "private", "protected"
	Components  []RecordComponent // record components
	Methods     []MethodDecl      // additional methods
}

type ReturnStmt struct{ Value Expr }

type SelectCase struct {
	IsRecv  bool   // true for recv case, false for closed case
	RecvVar string // variable name for received value (optional)
	Channel Expr   // channel expression
	Body    []Stmt // statements to execute if this case is selected
}

type SelectStmt struct {
	Cases []SelectCase
	Pos   Position
}

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

type StringLit struct{ Value string }

type SuperExpr struct {
	Args []Expr
}

type SwitchCase struct {
	// For value matching: case value:
	Values []Expr // values to match (can have multiple values per case)

	// For type matching: case (x: Type):
	TypeName string // type name for type matching
	VarName  string // variable name for type matching (optional)

	Body []Stmt // statements to execute if this case matches
}

type SwitchStmt struct {
	Expr    Expr         // expression to switch on (can be nil for type switches)
	Cases   []SwitchCase // switch cases
	Default []Stmt       // default case body (optional)
	Pos     Position
}

type TernaryExpr struct {
	Condition   Expr
	TrueBranch  Expr
	FalseBranch Expr
}

type ThreadJoinExpr struct {
	Thread Expr // thread expression to join
}

type ThreadSpawnExpr struct {
	Body []Stmt // thread body statements
}

type ThrowStmt struct {
	Value Expr
}

type TryStmt struct {
	Body    []Stmt
	Catches []CatchClause // can have multiple catch clauses
	Finally []Stmt        // optional finally block
}

type Type struct {
	Name        string   // Canonical name of the type (e.g., "bool", "int", "String", "Array")
	Aliases     []string // Alternative names for the type (e.g., ["boolean"] for bool)
	TypeParams  []*Type  // Type parameters for generic types (e.g., [Int] for Array<Int>, [String, Int] for Map<String, Int>)
	UnionTypes  []*Type  // Union type members (e.g., [string, int] for string | int)
	GoParallel  bool     // Whether this type supports parallel operations (optional, defaults to false)
	IsBuiltin   bool     // Whether this is a built-in type
	IsClass     bool     // Whether this is a class type
	IsInterface bool     // Whether this is an interface type
	IsEnum      bool     // Whether this is an enum type
	IsRecord    bool     // Whether this is a record type
	IsUnion     bool     // Whether this is a union type
}

type TypeAliasStmt struct {
	Name      string   // Alias name (e.g., "Age")
	BaseType  string   // Base type name (e.g., "Int")
	IsFinal   bool     // true if declared with 'final type' (nominal type)
	Modifiers []string // optional modifiers: public/private/protected
}

type TypeExpr struct {
	Expr Expr // the object to get type of
}

type TypeParam struct {
	IsWildcard   bool     // true if this is a wildcard (?)
	IsVariadic   bool     // true if this is a variadic type parameter (T...)
	Name         string   // Type name for concrete types (e.g., "Int", "String")
	WildcardKind string   // "unbounded", "extends", or "super" for wildcards
	Bounds       []string // Multiple bounds for wildcards (e.g., ["Number", "Comparable"] in "? extends Number & Comparable")
	Variance     string   // "in" (contravariance), "out" (covariance), or "" (invariant)
}

type UnaryExpr struct {
	Op int
	X  Expr
}