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
	// 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 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 // always true (strict mode only)

	// 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 call to an unresolved `eval` appears (unsupported)
	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 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 export entry in source order. Filled by the scope
	// pass; Binding is the module-scope binding the export reads.
	Exports []*ExportEntry
	// Async is set by the scope pass when the body awaits outside any
	// function (top-level await): the module evaluates asynchronously.
	Async bool
}

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 (generators, async, ...). The AST is still
	// produced, so supporting a feature lifts its restriction rather than
	// touching the parser.
	AllowUnsupported bool
}

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 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
	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
}

type SeqExpr struct {
	Span
	Exprs []Expr
}

type Span struct {
	Pos, End int
}

type SpreadElem struct {
	Span
	X Expr
}

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 // *Ident or *MemberExpr
}

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

type Visitor interface {
	Visit(n Node) Visitor
}

type WhileStmt struct {
	Span
	Cond Expr
	Body Stmt
}

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