syntax

type ArrayLit struct {
	Span
	Elems []Expr
	// contains filtered or unexported fields
}

type ArrayPattern struct {
	Span
	Elems []Pattern
	Rest  Pattern
}

type AssignExpr struct {
	Span
	Op          Token
	ParenTarget bool // Target is a parenthesised identifier: not an IdentifierRef, so the value is not named after it
	Target      Pattern
	Value       Expr
}

type AssignPattern struct {
	Span
	Target  Pattern
	Default Expr
}

type AwaitExpr struct {
	Span
	X Expr
}

type BigIntLit struct {
	Span
	Digits string
}

type BinaryExpr struct {
	Span
	Op   Token
	X, Y Expr
}

type BindKind uint8

type Binding struct {
	Name     string
	Kind     BindKind
	Scope    *Scope // declaring scope
	Slot     int    // index in Scope.Bindings
	Pos      int    // position of the (first) declaring identifier
	Captured bool   // referenced from a function nested inside the declaring function
	NeedsTDZ bool   // let/const/class that may be read before initialisation
	Exported bool   // module binding named by an export entry
	// AnnexB marks, on the binding of a block-level function declaration of
	// sloppy code, that evaluating the declaration also assigns the var
	// binding of the same name in the enclosing function or script scope
	// (Annex B.3.2); on a script-scope var binding, that only such
	// declarations create it.
	AnnexB bool
	// contains filtered or unexported fields
}

type BlockStmt struct {
	Span
	Body  []Stmt
	Scope *Scope
}

type BoolLit struct {
	Span
	Value bool
}

type BreakStmt struct {
	Span
	Label *Ident
}

type CallExpr struct {
	Span
	Callee   Expr
	Args     []Expr // may contain *SpreadElem
	Optional bool
}

type Class struct {
	Span
	Name    *Ident
	Super   Expr
	Members []*ClassMember

	// Scope annotations. Scope (kind ScopeClass) holds the inner name
	// binding, one binding per private name (named "#x") and the hidden
	// bindings of the class machinery; the heritage, the computed keys and
	// every member function are resolved inside it.
	Scope         *Scope
	NameBinding   *Binding  // inner immutable class-name binding (named classes)
	Ctor          *Function // the constructor; synthesized (DefaultCtor) when the body has none
	Fields        *Function // FuncClassFields: instance fields and the private-method brand (nil when none)
	Static        *Function // FuncClassStatic: static fields and blocks in order (nil when none)
	FieldsBinding *Binding  // hidden binding holding the Fields closure, read by the constructor
	BrandBinding  *Binding  // hidden binding holding the brand of the instance private methods (nil when none)
}

type ClassDecl struct {
	Span
	Class *Class
}

type ClassMember struct {
	Span
	Kind     ClassMemberKind
	Static   bool
	Key      Expr // *Ident, *StringLit, *NumberLit, *BigIntLit, *PrivateName, or computed Expr
	Computed bool
	Value    Expr       // *Function for methods, initializer for fields (may be nil)
	Body     *BlockStmt // static block body

	// Scope annotations. KeyBinding is the hidden binding that carries a
	// computed field key from class definition to the field initializer.
	// Block is a static block's body as an arrow function nested in
	// Class.Static, which gives it its own var scope and the static
	// initializer's this, home object and new.target.
	KeyBinding *Binding
	Block      *Function
}

type ClassMemberKind uint8

type CondExpr struct {
	Span
	Test, Cons, Alt Expr
}

type ContinueStmt struct {
	Span
	Label *Ident
}

type DebuggerStmt struct{ Span }

type DeclKind uint8

type Declarator struct {
	Span
	Target Pattern
	Init   Expr // may be nil
}

type DoWhileStmt struct {
	Span
	Body Stmt
	Cond Expr
}

type EmptyStmt struct{ Span }

type Error struct {
	Name string // file name given to ParseModule/ParseScript
	Pos  int    // byte offset into the source
	Line int    // 1-based line
	Col  int    // 1-based column in code points
	Msg  string
}

type Eval struct {
	Program
	// Strict marks strict eval code; Module marks eval code called in
	// module code; HasDirectEval marks code with a direct eval call, at any
	// depth.
	Strict, Module, HasDirectEval bool
	Func                          *Function
	// Env is the environment the code was resolved against. Levels are the
	// scopes of its levels, innermost first, holding the bindings the code
	// may look up: every one is Captured, its Slot the environment slot.
	Env    *EvalEnv
	Levels []*Scope
	// This is the synthetic function standing for the caller's function of
	// EvalEnv.This (nil at the top level): its hidden bindings are those of
	// the levels. FieldsBinding is the class's %fields binding for a derived
	// constructor.
	This          *Function
	FieldsBinding *Binding
	// The declarations of sloppy eval code in its caller's variable
	// environment (EvalDeclarationInstantiation): the var names, the
	// top-level functions to instantiate (the last declaration of each name,
	// in source order) and the names only Annex B.3.2.3 block functions
	// declare. They have no binding in Scope, and their references resolve
	// dynamically through the %evalvars object (or the global object).
	Vars   []string
	Funcs  []*FuncDecl
	AnnexB []string
}

type EvalEnv struct {
	// Levels are the scopes with a closure environment, innermost first.
	Levels []EvalLevel
	// Var is the level of the caller's variable environment (the scope
	// holding %evalvars), -1 for the global one. This is the outermost level
	// of the function supplying this (-1 outside any function), Fields the
	// level of the %fields binding a derived constructor's super() reads
	// (-1 when there is none).
	Var, This, Fields int
	// FuncKind is the kind of the function supplying this; Derived marks a
	// derived class constructor.
	FuncKind FuncKind
	Derived  bool
	// Strict is the strictness of the calling code; InParams marks a call
	// in the parameter list of a sloppy function with parameter expressions,
	// whose variable environment is outside the parameters; Module marks a
	// call in module code.
	Strict, InParams, Module bool
}

type EvalLevel interface {
	// Kind is the kind of the scope owning the environment; Len is the
	// number of its slots.
	Kind() ScopeKind
	Len() int
	// Slot returns the slot of the binding named name, or -1 when there is
	// none.
	Slot(name string) int
	// Binding describes slot i: its binding's name ("" for a slot without
	// one), kind and whether it has a TDZ.
	Binding(i int) (name string, kind BindKind, tdz bool)
}

type ExportAll struct {
	Span
	As     *Ident
	Source *StringLit
}

type ExportDecl struct {
	Span
	Decl Stmt // *VarDecl, *FuncDecl or *ClassDecl
}

type ExportDefault struct {
	Span
	Decl Node
}

type ExportEntry struct {
	Name    string   // exported name
	Local   string   // local binding name ("*default*" for an anonymous default export)
	Binding *Binding // module-scope binding
	Pos     int      // position of the export specifier or declaration
}

type ExportNamed struct {
	Span
	Specs  []*ExportSpec
	Source *StringLit
}

type ExportSpec struct {
	Span
	Local    *Ident
	Exported *Ident
}

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

type ExprStmt struct {
	Span
	X Expr
}

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

type ForInOfStmt struct {
	Span
	Of    bool
	Await bool // for await
	Left  Node
	Right Expr
	Body  Stmt
	Scope *Scope
}

type ForStmt struct {
	Span
	Init   Node
	Cond   Expr
	Update Expr
	Body   Stmt
	Scope  *Scope
}

type FuncDecl struct {
	Span
	Func *Function
}

type FuncKind uint8

type Function struct {
	Span
	Name        *Ident // nil when anonymous
	Params      []Pattern
	Rest        Pattern    // rest parameter target or nil
	Body        *BlockStmt // nil for a concise arrow body
	ExprBody    Expr       // concise arrow body
	Kind        FuncKind
	IsArrow     bool
	IsAsync     bool
	IsGenerator bool
	IsStrict    bool // strict mode code: a class member, inside strict code, or with its own "use strict"

	// Scope annotations.
	Scope           *Scope // parameters, var declarations and body-level lexical declarations (Body.Scope when kept apart)
	SelfBinding     *Binding
	UsesThis        bool // `this` (or super/new.target) appears in the body or in a nested arrow
	UsesArguments   bool // `arguments` appears in the body or in a nested arrow
	HasDirectEval   bool // a direct eval call appears in the function or a function nested in it
	ParamCount      int  // formal parameters excluding rest
	Length          int  // ES `length`: formals before the first default or rest
	HasSimpleParams bool // every formal is a plain identifier without default; no rest
	HasRest         bool

	// Class, super and new.target annotations. The hidden bindings live in
	// the function scope (registers or captured slots like any binding) and
	// are nil when unused.
	Derived          bool     // constructor of a class with an extends clause
	DefaultCtor      bool     // constructor synthesized for a class without one
	ThisBinding      *Binding // derived constructor: `this`, in TDZ until super() returns
	CalleeBinding    *Binding // derived constructor: the active function, read by super()
	NewTargetBinding *Binding // new.target, used here or in a nested arrow
	HomeBinding      *Binding // [[HomeObject]], for super property access here or in a nested arrow
}

type Ident struct {
	Span
	Name    string
	Binding *Binding
}

type IfStmt struct {
	Span
	Cond Expr
	Then Stmt
	Else Stmt // may be nil
}

type ImportCall struct {
	Span
	Source Expr
}

type ImportDecl struct {
	Span
	Default   *Ident
	Namespace *Ident
	Specs     []*ImportSpec
	Source    *StringLit
}

type ImportEntry struct {
	Request   int      // index in Module.Requests
	Name      string   // imported export name (unset for a namespace import)
	Namespace bool     // import * as Local: the binding is the module namespace object
	Binding   *Binding // local binding (BindImport, or BindImportNS for a namespace import)
	Pos       int      // position of the import specifier
}

type ImportMeta struct{ Span }

type ImportSpec struct {
	Span
	Imported *Ident
	Local    *Ident
}

type LabeledStmt struct {
	Span
	Label *Ident
	Body  Stmt
}

type LogicalExpr struct {
	Span
	Op   Token
	X, Y Expr
	// contains filtered or unexported fields
}

type MemberExpr struct {
	Span
	Object   Expr
	Prop     Expr
	Computed bool
	Optional bool
}

type Module struct {
	Program
	// Exports lists every local export entry in source order. Filled by the
	// scope pass; Binding is the module-scope binding the export reads.
	Exports []*ExportEntry
	// Requests lists the specifiers of the modules this module requests,
	// each once, in source order. Imports, Reexports and Stars refer to
	// them by index. All four are filled by the scope pass and are empty
	// for a module without import declarations or export ... from.
	Requests  []*ModuleRequest
	Imports   []*ImportEntry
	Reexports []*ReexportEntry
	Stars     []*StarExport
	// Async is set by the scope pass when the body awaits outside any
	// function (top-level await): the module evaluates asynchronously.
	// HasDirectEval is set by the scope pass when a direct eval call
	// appears in the module's code, at any depth.
	Async, HasDirectEval bool
	// contains filtered or unexported fields
}

type ModuleRequest struct {
	Specifier string // WTF-8 value of the string literal
	Pos       int    // position of its first occurrence
}

type NewExpr struct {
	Span
	Callee Expr
	Args   []Expr
}

type NewTarget struct {
	Span
	Binding *Binding
}

type Node interface {
	Range() (pos, end int)
}

type NullLit struct{ Span }

type NumberLit struct {
	Span
	Value float64
}

type ObjectLit struct {
	Span
	Props []*Property
	// contains filtered or unexported fields
}

type ObjectPattern struct {
	Span
	Props []*PatternProp
	Rest  Pattern // *Ident or (assignment only) *MemberExpr, or nil
}

type OptChain struct {
	Span
	X Expr // *MemberExpr or *CallExpr
}

type Options struct {
	// AllowUnsupported keeps the parser from rejecting syntax the engine
	// does not implement yet, so supporting a feature lifts its restriction
	// rather than touching the parser. No feature is deferred this way at
	// present (the proposals TestUnsupportedModuleSyntax lists fail
	// whatever the options); the option stays for the next one.
	AllowUnsupported bool
	// EarlyExports counts every exported function of a module as called
	// before the module's body runs, so the lexical bindings they read are
	// checked. A module that imports others always is; the linker asks for
	// this variant of an import-free module only when an import cycle can
	// call into it before its body ran (engine.LinkOptions.EarlyExports).
	EarlyExports bool
	// TypeScript makes ParseModule read TypeScript, whose type syntax it
	// erases: the tree is the one the type-erased JavaScript gives, with
	// every position in the TypeScript text. Import specifiers used only as
	// types are dropped, and TypeScript with run-time semantics (enums,
	// namespaces with values, parameter properties, import = require,
	// export =) is a syntax error. ParseScript rejects it: TypeScript code
	// is a module here.
	TypeScript bool
	// Stop, when set, is called before every stopEvery-th statement of each
	// statement list the parser and the resolver go through, the first
	// included: an error it returns ends the parse, which returns that error
	// rather than a *Error. The engine passes one that reports an interrupt,
	// so that one can stop a long compile of code from a string
	// (engine.Compiler); a host compile has none and pays nothing for it.
	Stop func() error
}

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

type PatternProp struct {
	Span
	Key      Expr // as Property.Key
	Computed bool
	Value    Pattern
}

type PrivateName struct {
	Span
	Name    string // without '#'
	Binding *Binding
}

type Program struct {
	Span
	File  *File
	Body  []Stmt
	Scope *Scope // module or script scope; filled by the scope pass
}

type PropKind uint8

type Property struct {
	Span
	Kind     PropKind
	Key      Expr // *Ident, *StringLit, *NumberLit, *BigIntLit, or any Expr when Computed; nil for PropSpread
	Computed bool
	Value    Expr // value, method *Function, spread operand, or cover default
}

type ReexportEntry struct {
	Name    string // exported name
	Request int    // index in Module.Requests
	Import  string // imported export name (unset when All)
	All     bool   // export * as Name from: the requested module's namespace object
	Pos     int
}

type RegexLit struct {
	Span
	Pattern string
	Flags   string
}

type ReturnStmt struct {
	Span
	Result Expr // may be nil
}

type Scope struct {
	Kind ScopeKind

	Parent   *Scope
	Func     *Function // enclosing function; nil at module/script level
	Node     Node      // owning node: *Module, *Script, *Function, *BlockStmt, *SwitchStmt, *TryStmt, *ForStmt, *ForInOfStmt, *Class, *WithStmt
	Bindings []*Binding
	Funcs    []*FuncDecl // hoisted function declarations to instantiate on entry, in source order
	Children []*Scope
	// contains filtered or unexported fields
}

type ScopeKind uint8

type Script struct {
	Program
	Strict, HasDirectEval bool
}

type SeqExpr struct {
	Span
	Exprs []Expr
}

type Span struct {
	Pos, End int
}

type SpreadElem struct {
	Span
	X Expr
}

type StarExport struct {
	Request int // index in Module.Requests
	Pos     int
}

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

type StringLit struct {
	Span
	Value string
}

type SuperExpr struct{ Span }

type SwitchCase struct {
	Span
	Test Expr
	Body []Stmt
}

type SwitchStmt struct {
	Span
	Disc  Expr
	Cases []*SwitchCase
	Scope *Scope
}

type TaggedTemplate struct {
	Span
	Tag   Expr
	Quasi *TemplateLit
}

type TemplateElement struct {
	Span
	Cooked string // WTF-8 cooked text, or InvalidCooked
	Raw    string // raw text with CR/CRLF normalised to LF
}

type TemplateLit struct {
	Span
	Quasis []TemplateElement
	Exprs  []Expr
}

type ThisExpr struct {
	Span
	Binding *Binding
}

type ThrowStmt struct {
	Span
	X Expr
}

type Token uint8

type TryStmt struct {
	Span
	Block      *BlockStmt
	Param      Pattern
	Handler    *BlockStmt
	Finalizer  *BlockStmt
	CatchScope *Scope
}

type UnaryExpr struct {
	Span
	Op Token
	X  Expr
}

type UpdateExpr struct {
	Span
	Op     Token // Inc or Dec
	Prefix bool
	X      Expr
}

type VarDecl struct {
	Span
	Kind  DeclKind
	Decls []*Declarator
}

type Visitor interface {
	Visit(n Node) Visitor
}

type WhileStmt struct {
	Span
	Cond Expr
	Body Stmt
}

type WithStmt struct {
	Span
	Object Expr
	Body   Stmt
	Scope  *Scope
}

type YieldExpr struct {
	Span
	X        Expr // may be nil
	Delegate bool
}