compiler

type ArrayLiteral struct {
	Elements []Expr
}

type AssignStmt struct {
	BaseStmt
	Target    string
	Value     Expr
	Namespace string // non-empty for top-level assignments from require'd files
}

type BaseStmt struct {
	SourceLine int // line number in the original .rg source
}

type BenchDef struct {
	BaseStmt
	Name string
	Body []Statement
}

type BinaryExpr struct {
	Left  Expr
	Op    string
	Right Expr
}

type BoolLiteral struct {
	Value bool
}

type BreakStmt struct{ BaseStmt }

type CallExpr struct {
	Func Expr
	Args []Expr
}

type CompileResult struct {
	GoSource   string
	Program    *Program
	SourceFile string // original .rg filename
}

type Compiler struct {
	// BaseDir is the directory of the main source file (for resolving requires).
	BaseDir string
	// TestMode enables test harness generation (rats blocks are included).
	// When false (default), rats blocks are silently skipped during codegen.
	TestMode bool
	// ModuleDir overrides the default module cache directory (~/.rugo/modules).
	// Used for testing. When empty, the default is used.
	ModuleDir string
	// contains filtered or unexported fields
}

type DotAssignStmt struct {
	BaseStmt
	Object Expr
	Field  string
	Value  Expr
}

type DotExpr struct {
	Object Expr
	Field  string
}

type ElsifClause struct {
	Condition Expr
	Body      []Statement
}

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

type ExprStmt struct {
	BaseStmt
	Expression Expr
}

type FloatLiteral struct {
	Value string
}

type FnExpr struct {
	Params []string
	Body   []Statement
}

type ForStmt struct {
	BaseStmt
	Var        string // value variable (or key for hashes)
	IndexVar   string // optional second variable (index for arrays, value for hashes)
	Collection Expr
	Body       []Statement
}

type FuncDef struct {
	BaseStmt
	Name      string
	Params    []string
	Body      []Statement
	Namespace string // set during require resolution for namespaced functions
}

type FuncTypeInfo struct {
	ParamTypes []RugoType
	ReturnType RugoType
}

type HashLiteral struct {
	Pairs []HashPair
}

type HashPair struct {
	Key   Expr
	Value Expr
}

type IdentExpr struct {
	Name string
}

type IfStmt struct {
	BaseStmt
	Condition    Expr
	Body         []Statement
	ElsifClauses []ElsifClause
	ElseBody     []Statement
}

type ImportStmt struct {
	BaseStmt
	Package string // Go package path (e.g. "strings", "path/filepath")
	Alias   string // optional alias (e.g. "fp" for filepath)
}

type IndexAssignStmt struct {
	BaseStmt
	Object Expr
	Index  Expr
	Value  Expr
}

type IndexExpr struct {
	Object Expr
	Index  Expr
}

type IntLiteral struct {
	Value string
}

type NextStmt struct{ BaseStmt }

type NilLiteral struct{}

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

type ParallelExpr struct {
	Body []Statement
}

type Program struct {
	Statements []Statement
	SourceFile string // display path of the source file
}

type RequireStmt struct {
	BaseStmt
	Path  string
	Alias string   // empty means use filename as namespace
	With  []string // selective sub-module names (mutually exclusive with Alias)
}

type ReturnStmt struct {
	BaseStmt
	Value Expr // nil if bare return
}

type RugoType int

type SliceExpr struct {
	Object Expr
	Start  Expr
	Length Expr
}

type SpawnExpr struct {
	Body []Statement // last expression is the task result
}

type Statement interface {
	Node

	StmtLine() int
	// contains filtered or unexported methods
}

type StringLiteral struct {
	Value string // raw string content including interpolation markers
	Raw   bool   // true for single-quoted raw strings (no escape processing)
}

type TestDef struct {
	BaseStmt
	Name string
	Body []Statement
}

type TryExpr struct {
	Expr    Expr        // expression to try
	ErrVar  string      // error variable name
	Handler []Statement // handler body; last expression is the result
}

type TypeInfo struct {
	// ExprTypes maps expressions to their inferred types.
	ExprTypes map[Expr]RugoType
	// FuncTypes maps function names to their inferred signatures.
	FuncTypes map[string]*FuncTypeInfo
	// VarTypes maps (scope, variable name) to their final inferred type.
	// Scope is the function name (or "" for top-level).
	VarTypes map[string]map[string]RugoType
}

type UnaryExpr struct {
	Op      string
	Operand Expr
}

type UseStmt struct {
	BaseStmt
	Module string
}

type WhileStmt struct {
	BaseStmt
	Condition Expr
	Body      []Statement
}