check

type APIDeclaration struct {
	Kind, Name, Receiver, Signature, Documentation string
	Position                                       diag.Pos
}

type Ambient struct {
	Decl *syntax.AmbientDecl
	Name string
	Pkg  *Package
	Type Type
	// Constraints are the facts of its type (`ambient id: String where
	// nonEmpty`): a with must prove them, and a function that needs the
	// value knows them.
	Constraints []*Constraint
	// Logged and Header are its markers: with also publishes a marked
	// value in the goroutine's labels, for log lines (logged) and for
	// the header Header of outgoing calls (propagated).
	Logged bool
	Header string
}

type ArgumentLabel struct {
	Name  string
	Pos   diag.Pos
	Param int
}

type Assembly struct {
	Mode      string             `json:"mode"`
	Target    string             `json:"target"`
	Result    string             `json:"result"`
	Effects   string             `json:"effects"`
	Tree      string             `json:"tree"`
	Providers []AssemblyProvider `json:"providers"`
	Roots     []AssemblyRoot     `json:"roots"`
	Order     []int              `json:"order"`
}

type AssemblyDependency struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	Provider int    `json:"provider,omitempty"`
	Scope    bool   `json:"scope,omitempty"`
}

type AssemblyProvider struct {
	Bundle        string               `json:"bundle,omitempty"`
	Entry         string               `json:"entry,omitempty"`
	EntryPosition *diag.Pos            `json:"entry_position,omitempty"`
	ID            int                  `json:"id"`
	Label         string               `json:"label"`
	Position      diag.Pos             `json:"position"`
	Product       string               `json:"product"`
	Dependencies  []AssemblyDependency `json:"dependencies"`
}

type AssemblyRoot struct {
	Name     string `json:"name,omitempty"`
	Type     string `json:"type"`
	Provider int    `json:"provider"`
}

type AsyncDescription struct {
	Scope    string   `json:"scope"`
	Effects  string   `json:"initializer_effects"`
	Captures []string `json:"captures,omitempty"`
}

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

type Binary struct {
	Op   syntax.Kind
	X, Y Expr
	// contains filtered or unexported fields
}

type Block struct {
	Assembly   *Assembly
	Conversion *SourceSpan
	Stmts      []Stmt
	Tail       Expr
	End        diag.Pos // the closing '}'
	// Labels are the bindings of a with's logged or propagated values,
	// which the block publishes in the goroutine's labels once its
	// statements (the with's bindings) have run, until it ends.
	Labels []*Var
	// contains filtered or unexported fields
}

type BuildRead struct {
	Pos        diag.Pos
	Kind, Path string
	Data       []byte
	Captured   bool
}

type Builtin int

type CArg struct {
	Const   constant.Value // nil for a parameter or sibling
	Param   string
	Type    Type // argument type, including inference from sibling fields
	Sibling bool // argument names a field of the enclosing record or variant
	// contains filtered or unexported fields
}

type Call struct {
	Func *Func
	Inst *Instance
	Args []Expr
	// Needs holds what the call passes for each of Func's needs (in
	// the order of Func.Needs): a VarRef, Option.Some of one, or
	// Option.None.
	Needs []Expr
	// ArgOrder lists parameter indices in source evaluation order; nil
	// means declaration order. Args remains in declaration order for facts.
	ArgOrder []int
	Labels   []ArgumentLabel
	// Embedded is set for a compile-time bork/embed call.
	Embedded  *Embedded
	BuildRead *BuildRead
	// ReceiverCall distinguishes x.method(a) from Type.method(x, a).
	ReceiverCall bool
	// TypeArgNames holds, per type parameter, an explicit type argument
	// that is a plain name, as written (Port, not Int); "" for others.
	TypeArgNames []string
	// contains filtered or unexported fields
}

type CallBuiltin struct {
	Builtin Builtin
	// DebugText is the original argument text for dbg.
	DebugText string
	Name      string
	Args      []Expr
	// Conv describes a numeric conversion of a value that is not a
	// constant; nil for other builtins.
	Conv *Conversion
	// contains filtered or unexported fields
}

type CallValue struct {
	Fun  Expr
	Args []Expr
	// contains filtered or unexported fields
}

type CallableDescription struct {
	Requires             []string               `json:"requires,omitempty"`
	NamedArguments       bool                   `json:"named_arguments"`
	ParameterNamesAreAPI bool                   `json:"parameter_names_are_api"`
	Parameters           []ParameterDescription `json:"parameters"`
	// Needs lists the ambient values the function reads, as its
	// signature declares them (locale? for an optional one).
	Needs []string `json:"needs,omitempty"`
}

type Class struct {
	Name    string
	Decl    *syntax.ClassDecl
	Pkg     *Package
	Prelude bool
	Param   *TypeParam
	Methods []*Func // each has Class set, and Param as its type parameter
}

type ClassInstance struct {
	GoFieldDecoders []*Dict
	Name            string
	Decl            *syntax.InstanceDecl
	Pkg             *Package
	Prelude         bool
	Class           *Class
	TypeParams      []*TypeParam
	Type            Type
	// Methods holds the implementations, in the class's method order.
	Methods []*Func
	// Constraints are those of a constrained instance's type
	// (`Decode[Int where positive]`). Such an instance is used only for
	// values known to satisfy them.
	Constraints []*Constraint
}

type Comptime struct {
	Body     *Block
	Owner    *Func
	Captures []*Var
	Value    Expr
	// contains filtered or unexported fields
}

type Const struct {
	Value constant.Value
	// SourceSpan covers folded arithmetic whose operand nodes are no longer
	// in the typed tree. Source queries select the complete folded value.
	SourceSpan *SourceSpan
	// contains filtered or unexported fields
}

type Constraint struct {
	Pred      *Func
	PredParam string
	Args      []CArg
	Pos       diag.Pos
	Or        []*Constraint
	Path      string
	Pkg       *Package // scope in which predicate dictionaries are resolved
}

type ConstructorHead struct {
	Start, End diag.Pos
	Uses       []TypeReference
}

type Conversion struct {
	From, To Type
	Checked  bool
}

type Copy struct {
	Candidate *Var
	X         Expr
	Updates   []*FieldUpdate
	// contains filtered or unexported fields
}

type DeferredKind uint8

type Derived struct {
	FieldDicts [][]*Dict
}

type Dict struct {
	Class *Class
	Type  Type
	// A declared instance:
	Inst     *ClassInstance
	TypeArgs []Type
	Args     []*Dict
	// Or a bound of a type parameter in scope:
	Param *TypeParam
	// Or built in: Eq for comparable types, or Show for every value.
	Builtin bool
}

type EditorCallEdge struct {
	Caller, Callee, SourceCallee EditorNavigationItem
	Start, End                   diag.Pos
}

type EditorExtraction struct {
	Function      *Func
	Parameters    []EditorExtractionParameter
	Result        Type
	WrittenResult string
	Effects       Effects
}

type EditorExtractionParameter struct {
	Name        string
	Type        Type
	Site        diag.Pos
	WrittenType string
}

type EditorInlay struct {
	Pos       diag.Pos
	Label     string
	Parameter bool
}

type EditorInlayOptions struct{ Types, Parameters, Facts bool }

type EditorNavigationItem struct {
	Name      string
	Pos       diag.Pos
	Kind      string
	Container string
}

type EditorSignature struct {
	Name, Result, Effects string
	Callable              *CallableDescription
	Definition            *diag.Pos
	ImplicitParameters    int
}

type Effects uint8

type Embedded struct {
	Pos   diag.Pos
	Kind  string
	Path  string
	Files []EmbeddedFile
}

type EmbeddedFile struct {
	Name      string
	StagePath string
	Data      []byte
}

type Evaluator func(queries []Query) ([]bool, error)

type ExecutionAudit struct {
	Decline      string
	Declarations []ExecutionDeclaration
	Intrinsics   []ExecutionIntrinsic
	Priors       []ExecutionPriorSite
}

type ExecutionDeclaration struct {
	Package, Name, Signature string
	Position                 diag.Pos
}

type ExecutionIntrinsic struct {
	Declaration    ExecutionDeclaration
	Contract       string
	Implementation [sha256.Size]byte
}

type ExecutionPriorSite struct {
	Position diag.Pos
	Type     string
}

type Expr interface {
	// Pos is where the expression starts.
	Pos() diag.Pos
	// TokenPos is the operator, call parenthesis, or selected name that
	// identifies this expression in source queries. Pos remains its start.
	TokenPos() diag.Pos
	Type() Type
	// contains filtered or unexported methods
}

type ExprStmt struct {
	X Expr
}

type Field struct {
	RuntimePackageReads bool

	Lazy         bool
	Computed     bool
	Dependencies []*Field
	DefaultVars  []*Var
	DefaultCalls []*Func

	GoTags  []syntax.GoTag
	Decl    *syntax.FieldDecl
	Pkg     *Package
	Prelude bool
	Doc     string
	Default Expr

	Name string
	Type Type
	// Constraints is the field's where clause.
	Constraints []*Constraint
	// contains filtered or unexported fields
}

type FieldUpdate struct {
	Thunk *Lambda
	Lazy  *LazyDescription
	Path  []string
	Field *Field
	Value Expr
}

type FieldValue struct {
	Thunk     *Lambda
	Lazy      *LazyDescription
	IsDefault bool
	Name      string
	Field     *Field
	Value     Expr
}

type FloatBits struct {
	Bits uint64
	// contains filtered or unexported fields
}

type For struct {
	Var   *Var
	Items Expr
	Body  *Block
	// contains filtered or unexported fields
}

type Func struct {
	RuntimePackageReads bool

	Decl *syntax.FuncDecl
	Pkg  *Package
	// Class is set for a class's method (which has no body), and Of for
	// the implementation of a method in an instance.
	Class *Class
	Of    *ClassInstance
	// Derived is set for an instance method the compiler writes.
	Derived *Derived
	// TypeParams lists a generic function's type parameters.
	TypeParams []*TypeParam
	Params     []Type
	Result     Type
	// Effects is what the function declares it may do (`uses io`).
	Effects Effects
	// Needs lists the ambient values it reads (`needs traceId`), in
	// the order of its hidden parameters, and NeedVars their variables.
	Needs    []*FuncNeed
	NeedVars []*Var
	// Prelude is set for the built-in functions of prelude.
	Prelude bool
	// TrackCaller adds a hidden source location for internal helper diagnostics.
	TrackCaller bool
	// Synthetic is set for a predicate that stands for a function
	// parameter (see facts.go); it has no body to run.
	Synthetic bool
	// Test is set for the function checking a test's body.
	Test *syntax.TestDecl
	// MockOf is set for the body of a `mock` statement in a test, checked
	// as a function with the signature of the function it mocks. Its
	// Decl.Params are the names the mock gives the parameters, and
	// MockIn is the test it is in.
	MockOf, MockIn *Func
	// Calls lists the functions this function's body calls.
	Calls []*Func
	// ParamVars are the variables of the parameters, and Body the typed
	// tree of the body (nil for a function implemented in Go).
	ParamVars []*Var
	Body      *Block
	Requires  Expr
	// ParamIn holds, per parameter, the index of the parameter (a Scope
	// or an OwnedScope) it is declared to belong to (`conn: Conn in
	// prev`), or -1.
	ParamIn []int

	ParamConstraints  [][]*Constraint
	ResultConstraints []MemberConstraints
	// contains filtered or unexported fields
}

type FuncNeed struct {
	Ambient  *Ambient
	Optional bool
	Decl     *syntax.Need
	// Type is the type the function's body reads the value as.
	Type Type
}

type FuncRef struct {
	Name string // as written
	Inst *Instance
	// Needs is what the reference binds for the function's needs, as
	// Call.Needs.
	Needs []Expr
	// contains filtered or unexported fields
}

type FuncType struct {
	Params []Type
	Result Type
	// Effects is what calling the function may do: `(A) uses io => C`.
	Effects Effects
}

type Generate struct {
	Body        *Block
	Constraints []*Constraint
	// contains filtered or unexported fields
}

type GoBinding struct {
	// Path is the Go package's import path, and Name the function's.
	Path, Name   string
	Receiver     types.Type
	ParamIndices []int
	ScopeIndex   int
	Sig          *types.Signature
	Shape        GoResultShape
	// Value is the bork type the Go result value converts to: the
	// result's leftmost member (an Option for GoValueOk), or nil.
	Value Type
	// Fallible is set when converting the result from Go can fail, so
	// the bork result has GoValueError.
	Fallible bool
	// Contextual resource results share generated, attachable cancellation.
	Contextual bool
	// GoError and GoValueError are the prelude's records, when the
	// result has them.
	GoError, GoValueError Type
}

type GoField struct {
	Tag  string
	Path []string
	Type types.Type
}

type GoNames interface {
	Names(paths []string) map[string]string
}

type GoResultShape int

type GoTypes interface {
	// Load returns the packages at the given import paths, and the
	// error of each that could not be loaded.
	Load(paths []string) (map[string]*types.Package, map[string]error)
}

type If struct {
	Cond Expr
	Then *Block
	Else Expr
	// contains filtered or unexported fields
}

type Info struct {
	Interpolations       map[Expr]*InterpolationSource
	InterpolationBatches []*InterpolationBatch

	PackageBindings []*PackageBinding

	// GoImportNames resolves unsafe Go imports without mutating source syntax.
	GoImportNames map[*syntax.GoCode]map[string]string

	// Packages lists the program's packages.
	Packages []*Package
	// Ambients lists the program's ambient declarations, in order.
	Ambients []*Ambient
	// Classes and ClassInstances list every class and instance.
	Classes        []*Class
	ClassInstances []*ClassInstance
	// Funcs holds the functions visible to the root package by name: its
	// own, and the prelude's that it does not replace.
	Funcs map[string]*Func
	// FuncOf holds every declared function, including prelude functions
	// the package replaced (the prelude still uses its own).
	FuncOf map[*syntax.FuncDecl]*Func
	// Named holds every declared type: *Record, *Sealed, or (for an
	// alias) the aliased type.
	Named map[string]Type
	// TypeOrder lists declared records and sealed types in source order.
	TypeOrder []Type
	// OutOfRange is the prelude's OutOfRange record.
	OutOfRange Type
	// Tests holds the root package's tests, each checked as a function
	// without parameters.
	Tests []*Func
	// Lifetimes holds the scopes each expression's value belongs to, and
	// VarLifetimes each variable's (see lifetimes.go), for queries.
	Lifetimes    map[Expr][]string
	VarLifetimes map[*Var][]string
	// Mocks holds the bodies of the tests' `mock` statements (see
	// Func.MockOf), and mocks them by statement.
	Mocks []*Func

	// MockCalls are the records of calls of the functions tests mock
	// with a handle (see callRecord), declared only in test builds.
	MockCalls     map[*Func]*Record
	MockCallOrder []*Record

	// Rules holds the inference rules of every package.
	Rules []*Rule
	// GoBindings holds every checked binding to a Go function
	// (`unsafe go "os.Getenv"`).
	GoBindings map[*Func]*GoBinding
	// Comptimes lists explicit build-time computations in lowering order.
	Comptimes []*Comptime

	// Embeds lists compile-time asset requests in source order.
	Embeds []*Embedded

	BuildReads []*BuildRead

	ProviderBundles []*ProviderBundle
	// contains filtered or unexported fields
}

type Instance struct {
	Func     *Func
	TypeArgs []Type
	Params   []Type
	Result   Type
	// Dicts holds the class instances the use needs: for a class method,
	// the class's; for a function with bounded type parameters, one per
	// bound, in order.
	Dicts []*Dict
	// ArgFacts holds, per type parameter, the constraints of an explicit
	// type argument (json.Decode[Port]): arguments of that type must
	// satisfy them, and results of it do (see callFunc).
	ArgFacts [][]*Constraint
}

type Interp struct {
	Parts []string
	Exprs []Expr
	// contains filtered or unexported fields
}

type InterpolationBatch struct {
	Recipe *Comptime
	Sites  []*InterpolationSite
}

type InterpolationSite struct {
	Prefix    diag.Pos
	Holes     []diag.Pos
	Validator string
	Package   string
	Call      *Call
	Key       string
	Index     int
}

type InterpolationSource struct {
	Prefix  SourceSpan
	Factory Expr
	Holes   []Expr
}

type KnownFact struct {
	Constraint string `json:"constraint"`
	Path       string `json:"path,omitempty"`
}

type Lambda struct {
	Params []*Var
	Body   Expr
	// contains filtered or unexported fields
}

type LazyDescription struct {
	Kind         string   `json:"kind"`
	Effects      string   `json:"initializer_effects"`
	Captures     []string `json:"captures,omitempty"`
	Dependencies []string `json:"dependencies,omitempty"`
}

type Let struct {
	Deferred   DeferredKind
	AsyncScope Expr
	Async      *AsyncDescription
	// Initializer holds a deferred initializer's function boundary; Value retains
	// its ordinary source type for effects and static proof checking.
	Initializer *Lambda
	Lazy        *LazyDescription
	Pos         diag.Pos
	Var         *Var
	Value       Expr
	// Declared is set when the binding's type is written; Constraints
	// are then its where clauses.
	Declared    bool
	Constraints []*Constraint
}

type List struct {
	Elem Type
}

type ListLit struct {
	Nil   bool
	Elems []Expr
	// contains filtered or unexported fields
}

type LoopControl struct {
	Continue bool
	// contains filtered or unexported fields
}

type Map struct {
	Key, Value Type
}

type MapLit struct {
	Keys, Values []Expr
	// contains filtered or unexported fields
}

type Match struct {
	X    Expr
	Arms []*MatchArm
	// contains filtered or unexported fields
}

type MatchArm struct {
	Pat  *Pat
	Body Expr
}

type MemberConstraints struct {
	Type        Type
	Constraints []*Constraint
}

type MethodDescription struct {
	Name       string               `json:"name"`
	Type       string               `json:"type,omitempty"`
	Definition *diag.Pos            `json:"definition,omitempty"`
	Ambiguity  string               `json:"ambiguity,omitempty"`
	Requires   []string             `json:"requires,omitempty"`
	Callable   *CallableDescription `json:"callable,omitempty"`
}

type Mock struct {
	Pos    diag.Pos
	Target *Func
	// Text is the target as written, at TargetPos.
	Text      string
	TargetPos diag.Pos
	Var       *Var
	Func      *Func
}

type Opaque struct {
	Name   string
	Decl   *syntax.TypeDecl
	Pkg    *Package
	GoType types.Type
}

type Package struct {
	Path string // the import path; "" for the prelude
	Name string // the last element of the path
	// Root is set for the package being built or tested; the others are
	// the packages it imports, directly or not.
	Root bool
	// GoPrefix starts the Go names of the package's functions and types
	// ("" for the root package and the prelude).
	GoPrefix string
	// Funcs holds the package's own functions by name.
	Funcs map[string]*Func
	// contains filtered or unexported fields
}

type PackageAPI struct {
	Path, Documentation string
	Unsafe              bool
	Declarations        []APIDeclaration
}

type PackageBinding struct {
	Decl         *syntax.Binding
	Pkg          *Package
	Type         Type
	Var          *Var
	Value        *Let
	Boundary     *Func
	Dependencies []*PackageBinding
	// contains filtered or unexported fields
}

type ParameterDescription struct {
	Doc      string `json:"doc,omitempty"`
	Name     string `json:"name"`
	Type     string `json:"type"`
	Receiver bool   `json:"receiver,omitempty"`
	Default  string `json:"default,omitempty"`
}

type Pat struct {
	Kind PatKind
	// Type is the type of the value matched at this position.
	Type Type
	// Bind, if not empty, names the value matched here; BindType is its
	// type (narrowed, for PatType), and bindNode the syntax node that
	// introduced it.
	Bind     string
	BindType Type

	// Var is the variable of the bound name in the typed tree, set
	// when the tree is built (see lower.go).
	Var *Var
	// Lit is the value of a PatLit (a number, string, or bool constant).
	Lit constant.Value
	// Variant is the variant of a PatVariant.
	Variant *Variant
	// Fields are the field patterns of a PatVariant or PatRecord, in
	// the order written. Missing fields match anything.
	Fields []*PatField
	// Members are the union members a PatType tests for, and Sub the
	// pattern for the narrowed value (nil: anything).
	Members []Type
	Sub     *Pat
	// Elems and Rest are the parts of a PatList; Rest (a wildcard,
	// possibly binding the remaining elements) is nil for a list of
	// exactly len(Elems) elements.
	Elems []*Pat
	Rest  *Pat
	// Guard is the runtime predicate condition, evaluated after the
	// structural tests succeed. guard is its syntax before lowering.
	Guard Expr
	// contains filtered or unexported fields
}

type PatField struct {
	Name string
	Pat  *Pat
}

type PatKind int

type Proof struct {
	Where  string `json:"where"`
	Proven bool   `json:"proven"`
	Reason string `json:"reason,omitempty"`
}

type ProviderBundle struct {
	Decl    *syntax.ProviderBundle
	Pkg     *Package
	Entries []*ProviderBundleEntry
}

type ProviderBundleDescription struct {
	Name       string                     `json:"name"`
	Definition diag.Pos                   `json:"definition"`
	Entries    []ProviderEntryDescription `json:"entries"`
}

type ProviderBundleEntry struct {
	Decl *syntax.ProviderEntry
	Func *Func
}

type ProviderEntryDescription struct {
	Needs        []string `json:"needs,omitempty"`
	Name         string   `json:"name"`
	Function     string   `json:"function"`
	Position     diag.Pos `json:"position"`
	Product      string   `json:"product"`
	Dependencies []string `json:"dependencies"`
	Effects      string   `json:"effects"`
	Failures     []string `json:"failures"`
	Replaced     bool     `json:"replaced,omitempty"`
}

type Query struct {
	Pred *Func
	// Values retain each closed argument's type for instantiated predicate calls.
	Values     []Expr
	ValueTexts []string
	Args       []constant.Value // the constrained value first
	// Subject, when set, is the constrained value as an expression of
	// constants (a list or record literal), shown as SubjectText; Args
	// then holds only the other arguments.
	Subject     Expr
	SubjectText string
	// TypeArgs are a generic predicate's type arguments, and Params its
	// parameter types with them filled in.
	TypeArgs []Type
	Params   []Type
	Dicts    []*Dict
	ArgFacts [][]*Constraint
	Or       []Query
	And      []Query
	// Via names the function whose result the constant is, when the
	// query comes from a derived result (see derive).
	Via string
}

type Record struct {
	GoGenerated  bool
	GoStruct     bool
	GoTo, GoFrom bool
	GoMirror     types.Type
	GoFields     []GoField
	Name         string
	Fields       []*Field
	Constraints  []*Constraint
	Decl         *syntax.TypeDecl
	Prelude      bool     // declared in prelude
	Pkg          *Package // the declaring package
	// MockCall is a mock's call record (see callRecord), which only
	// test builds declare.
	MockCall bool

	TypeParams []*TypeParam
	Base       *Record
	Args       []Type
	// contains filtered or unexported fields
}

type RecordLit struct {
	Candidate *Var
	// Promoted marks an implicit Some around a source expression.
	Promoted    bool
	Record      *Record
	Variant     *Variant
	Fields      []*FieldValue
	Head        *ConstructorHead
	Constraints []*Constraint
	// contains filtered or unexported fields
}

type Resource struct {
	GoType  types.Type
	Name    string
	Decl    *syntax.TypeDecl
	Prelude bool
	Pkg     *Package
}

type Return struct {
	Value Expr
	// contains filtered or unexported fields
}

type Rule struct {
	Decl     *syntax.RuleDecl
	Pkg      *Package
	VarTypes []Type // the types of Decl.Params
	Premises []*RuleAtom
	// Conditions are the premises that compute with the variables'
	// values, as typed expressions. They are evaluated on constants or
	// matched against branch comparisons; conditions holds
	// them as written.
	Conditions []Expr

	Conclusions []*RuleAtom
	// Vars are the rule's variables. PremiseExprs and ConclusionExprs
	// are its premises and conclusions as typed expressions, which test
	// mode runs, and ConclusionTexts the conclusions as written.
	Vars            []*Var
	PremiseExprs    []Expr
	ConclusionExprs []Expr
	ConclusionTexts []string
	// contains filtered or unexported fields
}

type RuleArg struct {
	Var       string
	Const     constant.Value
	ConstType Type
}

type RuleAtom struct {
	Inst *Instance
	Pred *Func
	Args []RuleArg // the subject first
}

type ScopeBlock struct {
	Var      *Var
	Policies []Expr
	Body     *Block
	// contains filtered or unexported fields
}

type Sealed struct {
	Name        string
	Variants    []*Variant
	Constraints []*Constraint
	Decl        *syntax.TypeDecl
	Prelude     bool     // declared in prelude
	Pkg         *Package // the declaring package

	TypeParams []*TypeParam
	Base       *Sealed
	Args       []Type
	// contains filtered or unexported fields
}

type Select struct {
	X     Expr
	Name  string
	Field *Field
	// contains filtered or unexported fields
}

type SemanticToken struct {
	Start, End                             diag.Pos
	Kind                                   string
	Declaration, Readonly, Static, Builtin bool
	GoBinding, Rebinding                   bool
}

type Seq struct {
	Elem    Type
	Effects Effects
}

type SeqCall struct {
	Op      string
	Args    []Expr
	Effects Effects
	// contains filtered or unexported fields
}

type SourceReference struct {
	Start, End, Definition diag.Pos
	Name                   string
	Declaration            bool
	Prefix, Suffix         string
}

type SourceSpan struct {
	Start diag.Pos `json:"start"`
	End   diag.Pos `json:"end"`
}

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

type Symbol struct {
	Name, Kind, Package, Container string
	Declaration, Definition, End   diag.Pos
	Exported                       bool
}

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

type Trust struct {
	Pos         diag.Pos
	Call        Expr
	Text        string
	SubjectText string
}

type Try struct {
	X Expr
	TryInfo
	// contains filtered or unexported fields
}

type TryInfo struct {
	// Kept is the type `?` produces.
	Kept Type
	// Rest lists the union members returned from the function (for a
	// union operand).
	Rest []Type
	// Option is the operand's type when it is an Option, and NoneOf the
	// Option type that `None` is returned as.
	Option *Sealed
	NoneOf *Sealed
}

type Type interface {
	String() string
}

type TypeParam struct {
	Name string
	Decl *syntax.TypeParam
	// Bounds lists the classes the type must have instances of.
	Bounds []*Class
	// contains filtered or unexported fields
}

type TypeReference struct {
	Pos        diag.Pos
	Name       string
	Type       Type
	Definition *diag.Pos
}

type Unary struct {
	Op syntax.Kind
	X  Expr
	// contains filtered or unexported fields
}

type Union struct {
	Members []Type
}

type UnmockedPath struct {
	Pos    diag.Pos
	Funcs  []*Func
	InMock *Func
}

type Var struct {
	PackageBinding *PackageBinding

	Sibling     *Field
	Unvalidated bool
	// Label describes a compiler-generated variable in diagnostics.
	Label string
	Name  string
	// GoName is the variable's name in the generated Go, when it is not
	// Name (an ambient value's binding or hidden parameter).
	GoName string
	Pos    diag.Pos
	Type   Type
	Kind   VarKind
	// Index is a parameter's position among its function's (or
	// lambda's, or rule's) parameters.
	Index int
	// Let is a VarLet's binding.
	Let *Let
	// Source is where a VarPattern's value comes from.
	Source *VarSource
	// Need is the need a VarAmbient reads.
	Need *FuncNeed
	// Ambient is the ambient value a with binding (a VarLet) binds.
	Ambient *Ambient
	// Unused is set for a binding or pattern name that is never read.
	Unused bool
}

type VarKind int

type VarRef struct {
	Var *Var
	// contains filtered or unexported fields
}

type VarSource struct {
	Subject Expr
	Member  Type
	Path    string
	Field   *Field
}

type Variant struct {
	Name        string
	Fields      []*Field
	Constraints []*Constraint
	Parent      *Sealed
	Index       int
}

type VariantValue struct {

	// ProofSource retains facts when a proof-only value narrows its source.
	ProofSource Expr
	Variant     *Variant
	Text        string
	Head        *ConstructorHead
	Constraints []*Constraint
	// contains filtered or unexported fields
}

type Yield struct {
	Value Expr
	Elem  Type
	// contains filtered or unexported fields
}