hare

type AllocExpression struct {
	Token  Token
	Init   Expression
	Cap    Expression
	Expand bool
	Free   bool
}

type AppendExpression struct {
	Token  Token
	Target Expression
	Value  Expression
	Len    Expression
	Expand bool
	Static bool
}

type ArrayLiteral struct {
	Start, End Token
	Members    []Expression
	Expand     bool
}

type ArrayType struct {
	Elem           *Type
	Size           Expression
	Unbounded      bool
	ContextDefined bool
}

type AssertExpression struct {
	Token   Token
	Assert  Expression
	Message string
	Static  bool
}

type AssignmentExpression struct {
	Target   Expression
	Operator Token
	Value    Expression
}

type BinaryExpression struct {
	L, R     Expression
	Operator Token
}

type Binding struct {
	Names []Token
	Type  *Type
	Value Expression
	Attr  *DeclAttr
}

type BindingExpression struct {
	Token
	Static   bool
	Const    bool
	Bindings []Binding
}

type BoolLiteral struct{ Token }

type CallExpression struct {
	Func   Expression
	Args   []Expression
	Unwrap bool
}

type CastExpression struct {
	Value Expression
	Cast  Token
	Type  *Type
}

type CompoundExpression struct {
	Start, End  Token
	Label       Token
	Expressions []Expression
}

type ConstantDeclaration struct {
	Type  *Type
	Value Expression
}

type ControlExpression struct {
	Control    Token
	Label      Token
	Expression Expression
}

type DeclAttr struct {
	Attr string
	Arg  string
}

type Declaration struct {
	Comment []string
	Export  bool
	Name    *Identifier
	Ignore  bool
	Data    interface{}
}

type DeferExpression struct {
	Token
	Expression
}

type DeleteExpression struct {
	Token  Token
	Target Expression
	Static bool
}

type EnumReference struct {
	Type  *EnumType
	Index int
}

type EnumType struct {
	Storage TypeStorage
	Members []EnumValue
}

type EnumValue struct {
	Name  Token
	Value Expression
}

type Error struct {
	Message string
	Range
}

type ErrorPropExpression struct {
	Value    Expression
	Operator Token
}

type Expression interface {
	Range() Range
}

type FieldAccessExpression struct {
	Prefix Expression
	Name   Token
	Index  int
}

type File struct {
	Name    string
	Version int
}

type FloatLiteral struct {
	Token
	Value float64
	Type  *Type
}

type ForExpression struct {
	Token
	Binding      *BindingExpression
	Condition    Expression
	Afterthought Expression
	Body         Expression
}

type FunctionAttrType int

type FunctionDeclaration struct {
	Prototype FunctionType
	Body      Expression
	Symbol    string
	Attr      FunctionAttrType
}

type FunctionType struct {
	NoReturn   bool
	Parameters []Parameter
	Varargs    bool
	CVarargs   bool
	Result     *Type
}

type GlobalDeclaration struct {
	Const  bool
	Type   *Type
	Value  Expression
	Symbol string
}

type IConstType struct {
	Min, Max int64
	Uint     bool
}

type Identifier struct {
	Names []Token
	Unit  *Unit
}

type IfExpression struct {
	Token
	Condition Expression
	Then      Expression
	Else      Expression
}

type Import struct {
	Alias   string
	Module  Identifier
	All     bool
	Members []ImportMember
}

type ImportMember struct {
	Alias string
	Name  Token
}

type IndexingExpression struct {
	Prefix Expression
	Index  Expression
}

type InsertExpression struct {
	Token  Token
	Target Expression
	Value  Expression
	Expand bool
	Static bool
}

type IntLiteral struct {
	Token
	Value int64
	Type  *Type
}

type LengthExpression struct {
	Token      Token
	Expression Expression
}

type MatchCase struct {
	Names  []Token
	Type   *Type
	Result []Expression
}

type MatchExpression struct {
	Token
	Value Expression
	Cases []MatchCase
}

type Module struct {
	// fully-qualified name, e.g. "encoding::utf8"
	Name string
	// file system path, e.g. "/usr/src/hare/stdlib/encoding/utf8"
	// or empty if the module was not found
	Path         string
	Declarations map[string]*Declaration
	Exports      map[string]*Declaration

	// The last I/O error encountered while loading the module. This hints at a
	// misconfigured hare installation or HAREPATH.
	// The module can still be used even if this error is set, but it is likely
	// missing declarations.
	LoadError *ModuleError
	// The last error caused by ambiguos tags. This may be resolved after adding
	// or removing files.
	// The module can still be used even if this error is set, but it is likely
	// missing declarations.
	TagError *ModuleConflictError
	// all files currently included in the module
	CurrentSources map[string]*Unit
	Cache          *ModuleCache
	// contains filtered or unexported fields
}

type ModuleCache struct {
	// The current working directory. If set, it is examined first while
	// searching for modules.
	WorkingDir string
	// The current tags, without the '+'; e.g. ["linux", "x86_64"]
	Tags []string
	// The current HAREPATH.
	Harepath []string

	OnLoad func(*Module)
	// contains filtered or unexported fields
}

type ModuleConflictError struct {
	Module string
	Path   string
	Names  []string
}

type ModuleError struct {
	Module string
	Path   string
	Cause  error
}

type NullLiteral struct{ Token }

type OffsetExpression struct {
	Token Token
	FieldAccessExpression
}

type Parameter struct {
	Name Token
	Type *Type
}

type Position struct {
	Line, Index int
}

type Range struct {
	Start, End Position
	File       *File
}

type RuneLiteral struct {
	Token
	Value rune
}

type SizeExpression struct {
	Token Token
	Type  *Type
}

type SlicingExpression struct {
	Prefix     Expression
	Start, End Expression
}

type StringLiteral struct {
	Token
	Value string
}

type StructField struct {
	Offset     Expression
	Name       Token
	Type       *Type
	Identifier *Identifier
}

type StructFieldValue struct {
	Name  Token
	Type  *Type
	Value Expression
}

type StructLiteral struct {
	Type   *Identifier
	Fields []StructFieldValue
	Fill   bool
}

type StructType struct {
	Union  bool
	Fields []StructField
}

type SwitchCase struct {
	Options []Expression
	Result  []Expression
}

type SwitchExpression struct {
	Token
	Value Expression
	Cases []SwitchCase
}

type TaggedUnionType struct {
	Types []*Type
}

type Token struct {
	File      *File
	Raw       string
	Line, Pos int
	Type      TokenType
}

type TokenType int

type Tokens struct {
	Src []Token
	// contains filtered or unexported fields
}

type Tuple struct {
	Start, End Token
	Content    []Expression
}

type TupleType struct {
	Types []*Type
}

type Type struct {
	Storage TypeStorage
	Const   bool
	Error   bool
	Alias   *Identifier
	Data    TypeData
	Range   Range

	Size  int
	Align int
	// contains filtered or unexported fields
}

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

type TypeDeclaration struct {
	Type *Type
}

type TypeStorage int

type UnaryExpression struct {
	Value    Expression
	Operator Token
}

type Unit struct {
	File *File
	// the module this unit is part of, may be nil
	Module *Module

	Imports      []Import
	Declarations []*Declaration
	Errors       []*Error
}

type VoidLiteral struct{ Token }