syntax

type AmbientDecl struct {
	Pos  diag.Pos
	Name string
	Type *TypeExpr
	// Logged is the position of the logged marker, if present.
	Logged *diag.Pos
	// Propagated is the propagated marker, if present.
	Propagated *Propagated
}

type Argument struct {
	Name              string
	Pos, NameEnd, End diag.Pos
	ValueStart        diag.Pos
	// RemovalStart includes the preceding comma, when no comment would
	// be removed with it. Zero for the first argument or commented spans.
	RemovalStart diag.Pos
}

type Arm struct {
	Pattern Pattern
	Body    Expr
}

type Binary struct {
	Pos  diag.Pos // position of the operator
	Op   Kind
	X, Y Expr
}

type Binding struct {
	// Package values use process-lifetime memo cells, including without lazy.
	Package    bool
	AsyncScope Expr
	AsyncPos   diag.Pos
	Lazy       bool
	LazyPos    diag.Pos
	Pos        diag.Pos
	Name       string
	Type       *TypeExpr // nil if not written
	Value      Expr
}

type Block struct {
	Pos   diag.Pos
	Stmts []Stmt
	Tail  Expr
	End   diag.Pos // position of the closing '}'
}

type BoolLit struct {
	Pos   diag.Pos
	Value bool
}

type Bundle struct {
	Pos   diag.Pos
	Name  string
	Items []*Use // instances, bundles, and pkg.* of imported packages
}

type Call struct {
	Start  diag.Pos // start of the callee, including grouping parentheses
	Pos    diag.Pos // position of '('
	End    diag.Pos // position after the closing ')'
	Fun    Expr
	FunEnd diag.Pos // position after the callee, before type arguments
	Args   []Expr
	// Arguments retains labels and source ranges, parallel to Args. A
	// synthesized pipeline input has no label.
	Arguments []Argument
	// TypeArgs are explicit type arguments: `empty[Int]()`.
	TypeArgs []*TypeExpr
	// Pipe retains the source of a desugared pipeline for diagnostics.
	Pipe               diag.Pos
	PipeStart, PipeEnd diag.Pos // range of the receiver expression
	PipeTargetEnd      diag.Pos // end of the original pipeline target
	PipeWrap           bool     // receiver needs parentheses before a selector
	PipeBare           bool     // target was written without call parentheses
}

type ClassDecl struct {
	Pos        diag.Pos
	Name       string
	TypeParams []*TypeParam
	Methods    []*FuncDecl
}

type Comment struct {
	Text string
	Pos  diag.Pos
	End  diag.Pos // position immediately after the token
}

type Comptime struct {
	Pos  diag.Pos
	Body *Block
}

type ContextName struct {
	Pos, End diag.Pos
	Name     string
}

type Copy struct {
	Pos     diag.Pos // position of 'copy'
	X       Expr
	Updates []*CopyUpdate
}

type CopyUpdate struct {
	PathEnd              diag.Pos
	ValueStart, ValueEnd diag.Pos
	Pos                  diag.Pos
	Path                 []string
	Value                Expr
}

type Effect struct {
	Pos  diag.Pos
	Name string
}

type Expr interface {
	Position() diag.Pos
	// contains filtered or unexported methods
}

type ExprStmt struct {
	X Expr
}

type ExpressionSpan struct {
	Expr Expr
	SourceSpan
}

type FieldDecl struct {
	Lazy    bool
	LazyPos diag.Pos
	GoTags  []GoTag
	Default Expr
	Doc     string
	Pos     diag.Pos
	Name    string
	Type    *TypeExpr
}

type FieldInit struct {
	Pos   diag.Pos
	Name  string
	Value Expr
}

type FieldPat struct {
	Pos     diag.Pos
	Field   string
	Pattern Pattern // nil for the `{ radius }` shorthand
}

type File struct {
	// ExpressionSpans retains parser ranges, including grouping, for compiler
	// source queries and refactorings. One node can have several grouped spans.
	ExpressionSpans []ExpressionSpan
	// Script marks a single executable file with an implicit main.
	Script bool
	Path   string
	// Source retains the original text for compile-time debug probes.
	Source string
	// Package is the import path of the file's package (set by the
	// driver), and Imports what the file imports.
	Package   string
	Imports   []*Import
	Uses      []*Use
	Bundles   []*Bundle
	Providers []*ProviderBundle
	Rules     []*RuleDecl
	// Classes and Instances; the instances' methods are also in Funcs.
	Classes   []*ClassDecl
	Instances []*InstanceDecl
	// Prelude is set for the compiler's built-in prelude.
	Prelude  bool
	Types    []*TypeDecl
	Ambients []*AmbientDecl
	Funcs    []*FuncDecl
	// Bindings contains immutable package values.
	Bindings []*Binding
	Tests    []*TestDecl
	Comments []Comment
}

type FloatLit struct {
	Pos  diag.Pos
	Text string
}

type For struct {
	Pos     diag.Pos
	Name    string
	NamePos diag.Pos
	Items   Expr
	Body    *Block
}

type FuncDecl struct {
	// ScriptMain is the synthetic entrypoint of a script.
	ScriptMain bool
	// Constructor names the owning record in `fn New = Config.new`.
	Constructor *TypeExpr
	Pos         diag.Pos
	End         diag.Pos // just after the complete declaration, including a body when present
	Name        string
	// IsPred is set for `pred name(x: T, ...) { ... }`: a function
	// returning Bool that can be used in `where` clauses.
	IsPred bool
	// TypeParams lists the type parameters of a generic function:
	// `fn map[A, B](...)`.
	TypeParams []*TypeParam
	Params     []*Param
	// ParamsEnd is the position of the ')' that ends the parameters.
	ParamsEnd diag.Pos
	// Requires relates function inputs; result constraints remain on Result.
	Requires Expr
	// Uses lists the effects the function may have, `uses io + net`,
	// or is nil when it declares none.
	Uses *Uses
	// Needs lists the ambient values it reads, `needs traceId +
	// locale?`, or is nil when it reads none.
	Needs  *Needs
	Result *TypeExpr
	Body   *Block
	GoBody *GoCode
	// GoBind is set instead of a body for a binding to a Go function:
	// `fn Getenv(key: String): String unsafe go "os.Getenv"`.
	GoBind *GoBind
	// Instance is set for a method of an instance declaration.
	Instance *InstanceDecl
	// IsMethod is set for a method, `fn (xs: List[T]) first[T](): T`:
	// its receiver is its first parameter.
	IsMethod bool
}

type FuncTypeExpr struct {
	Params []*TypeExpr
	Uses   *Uses
	Result *TypeExpr
}

type Generate struct {
	Pos  diag.Pos
	Elem *TypeExpr
	Body *Block
}

type GoBind struct {
	Pos  diag.Pos // position of the string
	Name string
}

type GoCode struct {
	Pos     diag.Pos // position of '{'
	Imports []string
	// ImportAliases contains explicit aliases by path.
	ImportAliases map[string]string
	// Body is the text between the braces, with the import lines
	// blanked out, so its lines still match the source.
	Body string
}

type GoTag struct {
	Pos         diag.Pos
	Name, Value string
}

type Ident struct {
	Pos  diag.Pos
	Name string
}

type If struct {
	Pos  diag.Pos
	Cond Expr
	Then *Block
	Else Expr
}

type Import struct {
	Pos  diag.Pos
	End  diag.Pos // after the quoted import path
	Name string   // what the file calls the package
	Path string
}

type InstanceDecl struct {
	Pos        diag.Pos
	Name       string
	TypeParams []*TypeParam
	Class      string // possibly qualified: fmt.Show
	ClassPos   diag.Pos
	Type       *TypeExpr
	Methods    []*FuncDecl
}

type IntLit struct {
	Pos  diag.Pos
	Text string
}

type Interp struct {
	Prefix    Expr     // nil for the built-in s prefix
	PrefixEnd diag.Pos // opening quote position for a named prefix
	Pos       diag.Pos
	Parts     []string
	Exprs     []Expr
}

type Kind int

type Lambda struct {
	Pos    diag.Pos
	Params []*Param
	Body   Expr
}

type ListLit struct {
	Pos   diag.Pos
	Elems []Expr
}

type ListPat struct {
	Pos     diag.Pos
	Elems   []Pattern
	HasRest bool
	Rest    string // "" when ignored
	RestPos diag.Pos
}

type LitPat struct {
	Pos   diag.Pos
	Value Expr
}

type LoopControl struct {
	Pos      diag.Pos
	Continue bool
}

type MapLit struct {
	Pos    diag.Pos
	Keys   []Expr
	Values []Expr
}

type Match struct {
	Pos               diag.Pos
	Close             diag.Pos // the closing brace, before which new arms can be inserted
	TrailingSeparator bool     // the final arm already has a comma or newline
	X                 Expr
	Arms              []*Arm
}

type MockStmt struct {
	Pos     diag.Pos // the binding's name, or 'mock'
	Name    string   // the handle's name, or ""
	MockPos diag.Pos // 'mock'
	Target  Expr
	Params  []*Param
	// ParamsStart and ParamsEnd are the positions of the '(' and ')'
	// around the parameters.
	ParamsStart, ParamsEnd diag.Pos
	// Requires relates function inputs; result constraints remain on Result.
	Requires Expr
	Body     *Block
}

type Need struct {
	Pos      diag.Pos
	Name     string // as written: traceId, or trace.Id
	Optional bool
}

type Needs struct {
	Pos   diag.Pos
	End   diag.Pos // just after the last need
	Items []*Need
}

type Param struct {
	Pos  diag.Pos
	Name string
	Type *TypeExpr
	// Default is the value of a function parameter that a call may
	// leave out (`attrs: Map[String, Int] = {:}`), or nil.
	Default Expr
	// In names the parameter (a Scope or an OwnedScope) whose scope this
	// one belongs to, in `conn: Conn in prev`; "" if none.
	In    string
	InPos diag.Pos
}

type Pattern interface {
	Position() diag.Pos
	// contains filtered or unexported methods
}

type PredRef struct {
	Pos  diag.Pos
	Name string
	Args []Expr
	Or   []*PredRef
}

type Propagated struct {
	Pos       diag.Pos
	Header    string
	HeaderPos diag.Pos
}

type ProviderBundle struct {
	Pos     diag.Pos
	NamePos diag.Pos
	Name    string
	Entries []*ProviderEntry
}

type ProviderEntry struct {
	Pos      diag.Pos
	Name     string
	Provider Expr
}

type RecordLit struct {
	Type   Expr // *Ident, *TypeHead, *Selector or *ContextName
	Fields []*FieldInit
	End    diag.Pos
}

type Return struct {
	Pos   diag.Pos
	Value Expr
}

type RuleDecl struct {
	Pos         diag.Pos
	Name        string
	Params      []*Param
	Premises    []Expr
	Conclusions []Expr
}

type RuneLit struct {
	Pos  diag.Pos
	Text string
}

type ScopeExpr struct {
	Pos  diag.Pos
	Name string
	// Policies are those of `scope s with taskTimeout(100),
	// cleanupTimeout(500) { ... }`; none for the defaults.
	Policies []Expr
	Body     *Block
}

type Selector struct {
	Pos  diag.Pos // position of the name
	X    Expr
	Name string
}

type SourceSpan struct{ Start, End diag.Pos }

type StaticPartsLit struct {
	Pos   diag.Pos
	Parts []string
}

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

type StringLit struct {
	Pos   diag.Pos
	Value string // unquoted
}

type TestDecl struct {
	Pos    diag.Pos
	Name   string
	Params []*Param
	Body   *Block
}

type Token struct {
	Kind Kind
	Text string
	Pos  diag.Pos
	End  diag.Pos // position immediately after the token
}

type TrustStmt struct {
	Pos  diag.Pos
	Call *Call
}

type Try struct {
	Pos diag.Pos // position of '?'
	X   Expr
}

type TypeDecl struct {
	Pos  diag.Pos
	Name string
	// TypeParams lists a generic type's parameters: `type Pair[A, B]`.
	TypeParams []*TypeParam
	GoName     *GoBind
	Kind       TypeKind
	Private    bool           // record construction belongs to its package
	Fields     []*FieldDecl   // RecordType
	Variants   []*VariantDecl // SealedType
	Alias      *TypeExpr      // AliasType
	Where      []*PredRef     // whole-value invariants on records and sealed types
	// Derive lists the classes to derive instances of:
	// `type User = { ... } derive (Decode, Encode)`.
	Derive    []string
	DerivePos diag.Pos
}

type TypeExpr struct {
	Uses *Uses // latent effects on Seq[T]

	Pos   diag.Pos
	Name  string
	Args  []*TypeExpr
	Union []*TypeExpr // non-nil for a union; Name and Args are then unused
	// Func is set for a function type `(A, B) => C`; Name and Args are
	// then unused.
	Func *FuncTypeExpr
	// Where lists the clauses of `T where p and (q(1) or r)`, all of
	// which must hold.
	Where []*PredRef
}

type TypeHead struct {
	Type *TypeExpr
	End  diag.Pos
}

type TypeKind int

type TypeParam struct {
	Pos  diag.Pos
	Name string
	// Bounds lists the classes the type must have instances of:
	// `T: Show + Eq`.
	Bounds []string
}

type TypePat struct {
	Pos  diag.Pos
	Name string
	Type *TypeExpr
}

type Unary struct {
	Pos diag.Pos
	Op  Kind
	X   Expr
}

type Use struct {
	Pos  diag.Pos
	Name string // "money.showAmount" or "money.*"
}

type Uses struct {
	Pos     diag.Pos
	End     diag.Pos // just after the last effect (or nothing)
	Effects []Effect
}

type VariantDecl struct {
	Pos    diag.Pos
	Name   string
	Fields []*FieldDecl
	Where  []*PredRef
}

type VariantPat struct {
	Pos    diag.Pos
	Path   []string
	Fields []*FieldPat
	Braces bool // written with { ... }, possibly empty
}

type WildcardPat struct{ Pos diag.Pos }

type WithBinding struct {
	Pos   diag.Pos
	Name  string // as written: traceId, or trace.Id
	Value Expr
}

type WithExpr struct {
	Pos      diag.Pos
	Bindings []*WithBinding
	Body     *Block
}

type Yield struct {
	Pos   diag.Pos
	Value Expr
}