ast

type AddressOfExpr struct {
	Token   lexer.Token // The 'reference' token
	Operand Expression  // The expression to take address of
}

type ArrowLambda struct {
	Token      lexer.Token  // The '=>' token
	Parameters []*Parameter // May have nil Type for untyped params
	Body       Expression   // Expression lambda: single expression (auto-return)
	Block      *BlockStmt   // Block lambda: multi-statement body (mutually exclusive with Body)
}

type AssignStmt struct {
	Targets []Expression // Can be single or multiple targets
	Values  []Expression // Right-hand side values (can be single or multiple)
	Token   lexer.Token  // The '=' token
	OnErr   *OnErrClause // Optional onerr clause (e.g., x = f() onerr panic "msg")
}

type BinaryExpr struct {
	Token    lexer.Token // The operator token
	Left     Expression
	Operator string
	Right    Expression
}

type BlockExpr struct {
	Token lexer.Token // The INDENT token
	Body  *BlockStmt
}

type BlockStmt struct {
	Token      lexer.Token // The '{' or INDENT token
	Statements []Statement
}

type BooleanLiteral struct {
	Token lexer.Token
	Value bool
}

type BreakStmt struct {
	Token lexer.Token // The 'break' token
}

type CallExpr struct {
	Token          lexer.Token // The '(' token or identifier
	Function       Expression
	Arguments      []Expression     // Positional arguments
	NamedArguments []*NamedArgument // Named arguments (e.g., name: value)
	Variadic       bool             // true if 'many' used: f(many args)
}

type ChannelType struct {
	Token       lexer.Token // The 'channel' token
	ElementType TypeAnnotation
}

type CloseExpr struct {
	Token   lexer.Token // The 'close' token
	Channel Expression
}

type ConstDecl struct {
	Token lexer.Token  // The 'const' token
	Specs []*ConstSpec // One or more name=value pairs
}

type ConstSpec struct {
	Name  *Identifier
	Value Expression // Required: const values must always be provided
}

type ContinueStmt struct {
	Token lexer.Token // The 'continue' token
}

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

type DeferStmt struct {
	Token lexer.Token // The 'defer' token
	Call  Expression  // Can be CallExpr or MethodCallExpr
}

type DerefExpr struct {
	Token   lexer.Token // The 'dereference' token
	Operand Expression  // The expression to dereference
}

type Directive struct {
	Token lexer.Token // The TOKEN_DIRECTIVE token
	Name  string      // Directive name (e.g., "deprecated", "fix")
	Args  []string    // Arguments (e.g., ["Use NewFunc instead"])
}

type DiscardExpr struct {
	Token lexer.Token // The 'discard' token
}

type ElseStmt struct {
	Token lexer.Token // The 'else' token
	Body  *BlockStmt
}

type EmptyExpr struct {
	Token lexer.Token // The 'empty' token
	Type  TypeAnnotation
}

type ErrorExpr struct {
	Token   lexer.Token // The 'error' token
	Message Expression  // Usually a string literal
}

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

type ExpressionStmt struct {
	Expression Expression
	OnErr      *OnErrClause // Optional onerr clause (e.g., f() onerr panic "msg")
}

type FieldAccessExpr struct {
	Token  lexer.Token // The '.' token
	Object Expression  // Can be nil for shorthand pipes: |> .Field
	Field  *Identifier
}

type FieldDecl struct {
	Name *Identifier
	Type TypeAnnotation
	Tag  string // Struct tag (e.g., `json:"name"`)
}

type FieldValue struct {
	Name  *Identifier
	Value Expression
}

type FloatLiteral struct {
	Token lexer.Token
	Value float64
}

type ForConditionStmt struct {
	Token     lexer.Token // The 'for' token
	Condition Expression
	Body      *BlockStmt
}

type ForNumericStmt struct {
	Token    lexer.Token // The 'for' token
	Variable *Identifier
	Start    Expression
	End      Expression
	Through  bool // true for 'through', false for 'to'
	Body     *BlockStmt
}

type ForRangeStmt struct {
	Token      lexer.Token // The 'for' token
	Variable   *Identifier
	Index      *Identifier // Optional (for index, item in collection)
	Collection Expression
	Body       *BlockStmt
}

type FunctionDecl struct {
	Token      lexer.Token // The 'func' token
	Name       *Identifier
	Parameters []*Parameter
	Returns    []TypeAnnotation
	Body       *BlockStmt
	Receiver   *Receiver   // For methods (optional)
	Directives []Directive // Attached `# kuki:` directives
}

type FunctionLiteral struct {
	Token      lexer.Token // The 'func' token
	Parameters []*Parameter
	Returns    []TypeAnnotation
	Body       *BlockStmt
}

type FunctionType struct {
	Token      lexer.Token      // The 'func' token
	Parameters []TypeAnnotation // Parameter types
	Returns    []TypeAnnotation // Return types
}

type GoStmt struct {
	Token lexer.Token // The 'go' token
	Call  Expression  // Can be CallExpr or MethodCallExpr (nil when Block is set)
	Block *BlockStmt  // Block form: go NEWLINE INDENT ... DEDENT (nil when Call is set)
}

type Identifier struct {
	Token lexer.Token
	Value string
}

type IfStmt struct {
	Token       lexer.Token // The 'if' token
	Init        Statement   // Optional initialization statement (can be nil)
	Condition   Expression
	Consequence *BlockStmt
	Alternative Statement // Can be ElseStmt or another IfStmt (else if)
}

type ImportDecl struct {
	Token lexer.Token // The 'import' token
	Path  *StringLiteral
	Alias *Identifier // Optional alias
}

type IncDecStmt struct {
	Token    lexer.Token // The '++' or '--' token
	Variable Expression
	Operator string // "++" or "--"
}

type IndexExpr struct {
	Token lexer.Token // The '[' token
	Left  Expression
	Index Expression
}

type IntegerLiteral struct {
	Token lexer.Token
	Value int64
}

type InterfaceDecl struct {
	Token      lexer.Token // The 'interface' token
	Name       *Identifier
	Methods    []*MethodSignature
	Directives []Directive // Attached `# kuki:` directives
}

type KeyValuePair struct {
	Key   Expression
	Value Expression
}

type ListLiteralExpr struct {
	Token    lexer.Token // The '[' token or 'list' keyword
	Type     TypeAnnotation
	Elements []Expression
}

type ListType struct {
	Token       lexer.Token // The 'list' token
	ElementType TypeAnnotation
}

type MakeExpr struct {
	Token lexer.Token // The 'make' token
	Type  TypeAnnotation
	Args  []Expression // Size/capacity for slices, channels
}

type MapLiteralExpr struct {
	Token   lexer.Token // The '{' token or 'map' keyword
	KeyType TypeAnnotation
	ValType TypeAnnotation
	Pairs   []*KeyValuePair
}

type MapType struct {
	Token     lexer.Token // The 'map' token
	KeyType   TypeAnnotation
	ValueType TypeAnnotation
}

type MethodCallExpr struct {
	Token          lexer.Token // The '.' token
	Object         Expression  // Can be nil for shorthand pipes: |> .Method()
	Method         *Identifier
	Arguments      []Expression     // Positional arguments
	NamedArguments []*NamedArgument // Named arguments (e.g., name: value)
	Variadic       bool             // true if 'many' used: obj.f(many args)
}

type MethodSignature struct {
	Name       *Identifier
	Parameters []*Parameter
	Returns    []TypeAnnotation
}

type NamedArgument struct {
	Token lexer.Token // The identifier token for the name
	Name  *Identifier
	Value Expression
}

type NamedType struct {
	Token lexer.Token // The identifier token
	Name  string
}

type Node interface {
	TokenLiteral() string
	Pos() Position
}

type OnErrClause struct {
	Token             lexer.Token // The 'onerr' token
	Handler           Expression  // Error handler (panic, error, empty, discard, or default value)
	Explain           string      // Optional explanation/hint for LLM (e.g., onerr explain "hint message")
	ShorthandReturn   bool        // True for bare "onerr return" — propagate error with zero values
	ShorthandContinue bool        // True for bare "onerr continue"
	ShorthandBreak    bool        // True for bare "onerr break"
	Alias             string      // Named alias for the caught error in block handlers (e.g., "onerr as e")
}

type OtherwiseCase struct {
	Token lexer.Token // The 'otherwise' or 'default' token
	Body  *BlockStmt
}

type PanicExpr struct {
	Token   lexer.Token // The 'panic' token
	Message Expression
}

type Parameter struct {
	Name         *Identifier
	Type         TypeAnnotation
	Variadic     bool       // true if "many" keyword used
	DefaultValue Expression // Optional default value (e.g., count int = 10)
}

type PetioleDecl struct {
	Token lexer.Token // The 'petiole' token
	Name  *Identifier
}

type PipeExpr struct {
	Token lexer.Token // The '|>' token
	Left  Expression
	Right Expression // Must be a function call
}

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

type PipedSwitchExpr struct {
	Token  lexer.Token     // The '|>' token
	Left   Expression      // The value being piped into the switch
	Switch PipedSwitchBody // The switch block itself
}

type Position struct {
	Line   int
	Column int
	File   string
}

type PrimitiveType struct {
	Token lexer.Token // The type token
	Name  string      // int, float, string, bool, etc.
}

type Program struct {
	Target       string        // Directive target (e.g., "mcp")
	PetioleDecl  *PetioleDecl  // Optional petiole declaration
	SkillDecl    *SkillDecl    // Optional skill declaration
	Imports      []*ImportDecl // Import declarations
	Declarations []Declaration // Top-level declarations (types, interfaces, functions)
}

type ReceiveExpr struct {
	Token   lexer.Token // The 'receive' token
	Channel Expression
}

type Receiver struct {
	Name *Identifier // The receiver variable name
	Type TypeAnnotation
}

type RecoverExpr struct {
	Token lexer.Token // The 'recover' token
}

type ReferenceType struct {
	Token       lexer.Token // The 'reference' token
	ElementType TypeAnnotation
}

type ReturnExpr struct {
	Token  lexer.Token // The 'return' token
	Values []Expression
}

type ReturnStmt struct {
	Token  lexer.Token // The 'return' token
	Values []Expression
}

type RuneLiteral struct {
	Token lexer.Token
	Value rune
}

type SelectCase struct {
	Token    lexer.Token  // The 'when' token
	Bindings []string     // [], ["v"], or ["v", "ok"]
	Recv     *ReceiveExpr // non-nil for receive cases
	Send     *SendStmt    // non-nil for send cases
	Body     *BlockStmt
}

type SelectStmt struct {
	Token     lexer.Token // The 'select' token
	Cases     []*SelectCase
	Otherwise *OtherwiseCase // Optional default case
}

type SendStmt struct {
	Token   lexer.Token // The 'send' token
	Value   Expression
	Channel Expression
}

type SkillDecl struct {
	Token       lexer.Token // The 'skill' token
	Name        *Identifier
	Description string // Description field
	Version     string // Version field
}

type SliceExpr struct {
	Token lexer.Token // The '[' token
	Left  Expression
	Start Expression // Can be nil
	End   Expression // Can be nil
}

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

type StringInterpolation struct {
	IsLiteral bool       // True for literal parts, false for expressions
	Literal   string     // For literal parts
	Expr      Expression // For expression parts
}

type StringLiteral struct {
	Token        lexer.Token
	Value        string
	Interpolated bool                   // True if contains {expr}
	Parts        []*StringInterpolation // For interpolated strings
}

type StructLiteralExpr struct {
	Token  lexer.Token // The type identifier
	Type   TypeAnnotation
	Fields []*FieldValue
}

type SwitchStmt struct {
	Token      lexer.Token // The 'switch' token
	Expression Expression  // Optional (nil for condition switch)
	Cases      []*WhenCase
	Otherwise  *OtherwiseCase // Optional
}

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

type TypeAssertionExpr struct {
	Token      lexer.Token // The '.' token
	Expression Expression
	TargetType TypeAnnotation
}

type TypeCase struct {
	Token lexer.Token    // The 'when' token
	Type  TypeAnnotation // The type to match
	Body  *BlockStmt
}

type TypeCastExpr struct {
	Token      lexer.Token // The 'as' token
	Expression Expression
	TargetType TypeAnnotation
}

type TypeDecl struct {
	Token      lexer.Token // The 'type' token
	Name       *Identifier
	Fields     []*FieldDecl   // nil for type aliases
	AliasType  TypeAnnotation // non-nil for type aliases (e.g., func(...) ...)
	Directives []Directive    // Attached `# kuki:` directives
}

type TypeSwitchStmt struct {
	Token      lexer.Token    // The 'switch' token
	Expression Expression     // The expression to switch on
	Binding    *Identifier    // The binding variable (e.g., e in "switch event as e")
	Cases      []*TypeCase    // Type cases
	Otherwise  *OtherwiseCase // Optional default branch
}

type UnaryExpr struct {
	Token    lexer.Token // The operator token
	Operator string
	Right    Expression
}

type VarDeclStmt struct {
	Names  []*Identifier
	Type   TypeAnnotation // Optional (can be nil for inference)
	Values []Expression   // Right-hand side values (can be single or multiple)
	Token  lexer.Token    // The identifier token or walrus token
	OnErr  *OnErrClause   // Optional onerr clause (e.g., x := f() onerr panic "msg")
}

type WhenCase struct {
	Token  lexer.Token // The 'when' or 'case' token
	Values []Expression
	Body   *BlockStmt
}