parser

type AliasDecl struct {
	Name string
	Type Type
	Span Span
}

type ArrayType struct {
	Element Type
	Size    Expr // nil for runtime-sized arrays
	Span    Span
}

type AssignStmt struct {
	Left  Expr
	Op    TokenKind // =, +=, -=, etc.
	Right Expr
	Span  Span
}

type Attribute struct {
	Name string
	Args []Expr
	Span Span
}

type BinaryExpr struct {
	Left  Expr
	Op    TokenKind
	Right Expr
	Span  Span
}

type BindingArrayType struct {
	Element Type
	Size    Expr // nil for unbounded
	Span    Span
}

type BitcastExpr struct {
	Type Type // Target type
	Expr Expr // Source expression
	Span Span
}

type BlockStmt struct {
	Statements []Stmt
	Span       Span
}

type BreakIfStmt struct {
	Condition Expr
	Span      Span
}

type BreakStmt struct {
	Span Span
}

type CallExpr struct {
	Func *Ident
	Args []Expr
	Span Span
}

type ConstAssertDecl struct {
	Condition Expr
	Span      Span
}

type ConstDecl struct {
	Name    string
	Type    Type
	Init    Expr
	Span    Span
	IsConst bool // true for `const`, false for `let`
}

type ConstructExpr struct {
	Type Type
	Args []Expr
	Span Span
}

type ContinueStmt struct {
	Span Span
}

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

type Diagnostic struct {
	Severity string
	Rule     string
	Span     Span
}

type DiscardStmt struct {
	Span Span
}

type Enable struct {
	Extensions []string
	Span       Span
}

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

type ExprStmt struct {
	Expr Expr
	Span Span
}

type ForStmt struct {
	Init      Stmt
	Condition Expr
	Update    Stmt
	Body      *BlockStmt
	Span      Span
}

type FunctionDecl struct {
	Name        string
	Params      []*Parameter
	ReturnType  Type
	ReturnAttrs []Attribute // Attributes on return type (e.g., @builtin(position), @location(0))
	Attributes  []Attribute
	Body        *BlockStmt
	Span        Span
}

type Ident struct {
	Name string
	Span Span
}

type IfStmt struct {
	Condition Expr
	Body      *BlockStmt
	Else      Stmt // *BlockStmt or *IfStmt
	Span      Span
}

type IndexExpr struct {
	Expr  Expr
	Index Expr
	Span  Span
}

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

type Literal struct {
	Kind  TokenKind // IntLiteral, FloatLiteral, BoolLiteral
	Value string
	Span  Span
}

type LoopStmt struct {
	Body       *BlockStmt
	Continuing *BlockStmt
	Span       Span
}

type MemberExpr struct {
	Expr   Expr
	Member string
	Span   Span
}

type Module struct {
	Enables     []Enable
	Diagnostics []Diagnostic
	Structs     []*StructDecl
	Functions   []*FunctionDecl
	GlobalVars  []*VarDecl
	Aliases     []*AliasDecl
	Constants   []*ConstDecl
	Overrides   []*OverrideDecl

	// Declarations preserves all top-level declarations in source order.
	// This is used by the lowerer to register types in the same order as
	// Rust naga, which processes declarations via topological sort that
	// closely follows source order.
	Declarations []Decl
}

type NamedType struct {
	Name       string
	TypeParams []Type
	Span       Span
}

type Node interface {
	Pos() Span
}

type OverrideDecl struct {
	Name       string
	Type       Type
	Init       Expr // May be nil (override without default value)
	Attributes []Attribute
	Span       Span
}

type Parameter struct {
	Name       string
	Type       Type
	Attributes []Attribute
	Span       Span
}

type ParseError struct {
	Message string
	Token   Token
}

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

type Position struct {
	Line   int
	Column int
	Offset int
}

type PtrType struct {
	AddressSpace string
	PointeeType  Type
	AccessMode   string
	Span         Span
}

type ReturnStmt struct {
	Value Expr
	Span  Span
}

type SourceError struct {
	Message string
	Span    Span
	Source  string // Original source code (for context display)
}

type SourceErrors []*SourceError

type Span struct {
	Start  Position
	End    Position
	Source string // Source file name or identifier
}

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

type StructDecl struct {
	Name    string
	Members []*StructMember
	Span    Span
}

type StructMember struct {
	Name       string
	Type       Type
	Attributes []Attribute
	Span       Span
}

type SwitchCaseClause struct {
	Selectors    []Expr     // Case selectors (nil or empty for default)
	IsDefault    bool       // True for default case
	DefaultFirst bool       // True when default appears before selectors (case default, 6:)
	Body         *BlockStmt // Case body
	Span         Span
}

type SwitchStmt struct {
	Selector Expr
	Cases    []*SwitchCaseClause
	Span     Span
}

type Token struct {
	Kind   TokenKind
	Lexeme string
	Line   int
	Column int
}

type TokenKind uint8

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

type UnaryExpr struct {
	Op      TokenKind
	Operand Expr
	Span    Span
}

type VarDecl struct {
	Name         string
	Type         Type
	Init         Expr
	AddressSpace string // function, private, workgroup, uniform, storage
	AccessMode   string // read, write, read_write
	Attributes   []Attribute
	Span         Span
}

type WhileStmt struct {
	Condition Expr
	Body      *BlockStmt
	Span      Span
}