checker

type And struct {
	Left, Right Expression
}

type AsyncPkg struct{}

type Block struct {
	Stmts []Statement
}

type BoolLiteral struct {
	Value bool
}

type BoolMatch struct {
	Subject Expression
	True    *Block
	False   *Block
}

type BoolMethod struct {
	Subject Expression
	Kind    BoolMethodKind
}

type BoolMethodKind uint8

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

type ConditionalCase struct {
	Condition Expression // Must be type Bool
	Body      *Block
}

type ConditionalMatch struct {
	Cases    []ConditionalCase
	CatchAll *Block
}

type CopyExpression struct {
	Expr  Expression
	Type_ Type
}

type Diagnostic struct {
	Kind    DiagnosticKind
	Message string
	// contains filtered or unexported fields
}

type DiagnosticKind string

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

type Enum struct {
	Name     string
	Private  bool
	Values   []EnumValue // The discriminant values for each variant
	Methods  map[string]*FunctionDef
	Traits   []*Trait
	Location parse.Location
}

type EnumMatch struct {
	Subject  Expression
	Cases    []*Block
	CatchAll *Block
}

type EnumValue struct {
	Name  string
	Value int // The computed integer discriminant
}

type EnumVariant struct {
	Variant int8
	// contains filtered or unexported fields
}

type Equality struct {
	Left, Right Expression
}

type Expression interface {
	Type() Type
}

type ExternalFunctionDef struct {
	Name            string
	Parameters      []Parameter
	ReturnType      Type
	ExternalBinding string
	Private         bool
}

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

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

type FloatAddition struct {
	Left  Expression
	Right Expression
}

type FloatDivision struct {
	Left  Expression
	Right Expression
}

type FloatGreater struct {
	Left  Expression
	Right Expression
}

type FloatGreaterEqual struct {
	Left  Expression
	Right Expression
}

type FloatLess struct {
	Left  Expression
	Right Expression
}

type FloatLessEqual struct {
	Left  Expression
	Right Expression
}

type FloatLiteral struct {
	Value float64
}

type FloatMethod struct {
	Subject Expression
	Kind    FloatMethodKind
}

type FloatMethodKind uint8

type FloatMultiplication struct {
	Left  Expression
	Right Expression
}

type FloatSubtraction struct {
	Left  Expression
	Right Expression
}

type ForInList struct {
	Cursor string
	Index  string
	List   Expression
	Body   *Block
}

type ForInMap struct {
	Key  string
	Val  string
	Map  Expression
	Body *Block
}

type ForInStr struct {
	Cursor string
	Index  string
	Value  Expression
	Body   *Block
}

type ForIntRange struct {
	Cursor string
	Index  string
	Start  Expression
	End    Expression
	Body   *Block
}

type ForLoop struct {
	Init      *VariableDef
	Condition Expression
	Update    *Reassignment
	Body      *Block
}

type FunctionCall struct {
	Name string
	Args []Expression
	// contains filtered or unexported fields
}

type FunctionDef struct {
	Name       string
	Parameters []Parameter
	ReturnType Type
	Mutates    bool
	Body       *Block
	Private    bool
}

type GenericContext = map[string]*TypeVar

type Identifier struct {
	Name string
	// contains filtered or unexported fields
}

type If struct {
	Condition Expression
	Body      *Block
	ElseIf    *If
	Else      *Block
}

type InstanceMethod struct {
	Subject Expression
	Method  *FunctionCall
}

type InstanceProperty struct {
	Subject  Expression
	Property string

	Kind SubjectKind // Pre-computed by checker based on subject type
	// contains filtered or unexported fields
}

type IntAddition struct {
	Left  Expression
	Right Expression
}

type IntDivision struct {
	Left  Expression
	Right Expression
}

type IntGreater struct {
	Left  Expression
	Right Expression
}

type IntGreaterEqual struct {
	Left  Expression
	Right Expression
}

type IntLess struct {
	Left  Expression
	Right Expression
}

type IntLessEqual struct {
	Left  Expression
	Right Expression
}

type IntLiteral struct {
	Value int
}

type IntMatch struct {
	Subject    Expression
	IntCases   map[int]*Block      // keys are integer values
	RangeCases map[IntRange]*Block // keys are integer ranges
	CatchAll   *Block
}

type IntMethod struct {
	Subject Expression
	Kind    IntMethodKind
}

type IntMethodKind uint8

type IntModulo struct {
	Left  Expression
	Right Expression
}

type IntMultiplication struct {
	Left  Expression
	Right Expression
}

type IntRange struct {
	Start int
	End   int
}

type IntSubtraction struct {
	Left  Expression
	Right Expression
}

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

type ListLiteral struct {
	Elements []Expression
	// contains filtered or unexported fields
}

type ListMethod struct {
	Subject     Expression
	Kind        ListMethodKind
	Args        []Expression
	ElementType Type // Pre-computed element type
	// contains filtered or unexported fields
}

type ListMethodKind uint8

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

type MapLiteral struct {
	Keys   []Expression
	Values []Expression

	KeyType   Type // Pre-computed by checker
	ValueType Type // Pre-computed by checker
	// contains filtered or unexported fields
}

type MapMethod struct {
	Subject   Expression
	Kind      MapMethodKind
	Args      []Expression
	KeyType   Type // Pre-computed key type
	ValueType Type // Pre-computed value type
	// contains filtered or unexported fields
}

type MapMethodKind uint8

type Match struct {
	Pattern *Identifier
	Body    *Block
}

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

type MaybeMethod struct {
	Subject   Expression
	Kind      MaybeMethodKind
	Args      []Expression
	InnerType Type // Pre-computed inner type
	// contains filtered or unexported fields
}

type MaybeMethodKind uint8

type MaybePkg struct{}

type Module interface {
	Path() string
	Get(name string) Symbol
	Program() *Program
}

type ModuleFunctionCall struct {
	Module string
	Call   *FunctionCall
}

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

type ModuleStructInstance struct {
	Module     string
	Property   *StructInstance
	FieldTypes map[string]Type // Pre-computed by checker
}

type ModuleSymbol struct {
	Module string
	Symbol Symbol
}

type Negation struct {
	Value Expression
}

type NonProducing interface {
	NonProducing()
}

type Not struct {
	Value Expression
}

type OptionMatch struct {
	Subject   Expression
	Some      *Match
	None      *Block
	InnerType Type // Pre-computed inner type of Maybe
}

type Or struct {
	Left, Right Expression
}

type Panic struct {
	Message Expression
	// contains filtered or unexported fields
}

type Parameter struct {
	Name    string
	Type    Type
	Mutable bool
}

type Program struct {
	Imports    map[string]Module
	Statements []Statement
}

type ProjectInfo struct {
	RootPath    string // absolute path to project root
	ProjectName string // project name from ard.toml or directory name
}

type Reassignment struct {
	Target Expression
	Value  Expression
}

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

type ResultMatch struct {
	Subject Expression
	Ok      *Match
	Err     *Match
}

type ResultMethod struct {
	Subject Expression
	Kind    ResultMethodKind
	Args    []Expression
	OkType  Type // Pre-computed OK type
	ErrType Type // Pre-computed Error type
	// contains filtered or unexported fields
}

type ResultMethodKind uint8

type ResultPkg struct {
}

type Statement struct {
	Break bool
	Expr  Expression
	Stmt  NonProducing
}

type StrAddition struct {
	Left  Expression
	Right Expression
}

type StrLiteral struct {
	Value string
}

type StrMethod struct {
	Subject Expression
	Kind    StrMethodKind
	Args    []Expression
}

type StrMethodKind uint8

type StructDef struct {
	Name    string
	Fields  map[string]Type
	Methods map[string]*FunctionDef
	Self    string
	Traits  []*Trait
	Private bool
}

type StructInstance struct {
	Name   string
	Fields map[string]Expression

	FieldTypes map[string]Type // Pre-computed by checker
	// contains filtered or unexported fields
}

type SubjectKind uint8

type Symbol struct {
	Name string
	Type Type
	// contains filtered or unexported fields
}

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

type TemplateStr struct {
	Chunks []Expression
}

type Trait struct {
	Name string
	// contains filtered or unexported fields
}

type TryKind uint8

type TryOp struct {
	CatchBlock *Block
	CatchVar   string
	Kind       TryKind // Pre-computed by checker: TryResult or TryMaybe
	// contains filtered or unexported fields
}

type Type interface {
	String() string
	// contains filtered or unexported methods
}

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

type Union struct {
	Name  string
	Types []Type
}

type UnionMatch struct {
	Subject   Expression
	TypeCases map[string]*Match
	CatchAll  *Block
}

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

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

type VariableDef struct {
	Mutable bool
	Name    string

	Value Expression
	// contains filtered or unexported fields
}

type VoidLiteral struct{}

type WhileLoop struct {
	Condition Expression
	Body      *Block
}