ast_expression.go

package javascript

import (
	"vimagination.zapto.org/parser"
)

// AssignmentOperator specifies the type of assignment in AssignmentExpression
type AssignmentOperator uint8

// Valid AssignmentOperator's
const (
	AssignmentNone AssignmentOperator = iota
	AssignmentAssign
	AssignmentMultiply
	AssignmentDivide
	AssignmentRemainder
	AssignmentAdd
	AssignmentSubtract
	AssignmentLeftShift
	AssignmentSignPropagatingRightShift
	AssignmentZeroFillRightShift
	AssignmentBitwiseAND
	AssignmentBitwiseXOR
	AssignmentBitwiseOR
	AssignmentExponentiation
	AssignmentLogicalAnd
	AssignmentLogicalOr
	AssignmentNullish
)

func (ao *AssignmentOperator) parse(j *jsParser) error {
	g := j.NewGoal()
	h := j.NewGoal()
	i := j.NewGoal()

	if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "="}) {
		*ao = AssignmentAssign
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "*="}) {
		*ao = AssignmentMultiply
	} else if g.AcceptToken(parser.Token{Type: TokenDivPunctuator, Data: "/="}) {
		*ao = AssignmentDivide
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "%="}) {
		*ao = AssignmentRemainder
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "+="}) {
		*ao = AssignmentAdd
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "-="}) {
		*ao = AssignmentSubtract
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "<<="}) {
		*ao = AssignmentLeftShift
	} else if h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ">"}) && h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ">"}) && h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "="}) {
		*ao = AssignmentSignPropagatingRightShift

		g.Score(h)
	} else if i.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ">"}) && i.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ">"}) && i.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ">"}) && i.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "="}) {
		*ao = AssignmentZeroFillRightShift

		g.Score(i)
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "&="}) {
		*ao = AssignmentBitwiseAND
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "^="}) {
		*ao = AssignmentBitwiseXOR
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "|="}) {
		*ao = AssignmentBitwiseOR
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "**="}) {
		*ao = AssignmentExponentiation
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "&&="}) {
		*ao = AssignmentLogicalAnd
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "||="}) {
		*ao = AssignmentLogicalOr
	} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "??="}) {
		*ao = AssignmentNullish
	} else {
		return ErrInvalidAssignment
	}

	j.Score(g)

	return nil
}

// AssignmentExpression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-AssignmentExpression
//
// It is only valid for one of ConditionalExpression, ArrowFunction,
// LeftHandSideExpression, and AssignmentPattern to be non-nil.
//
// If LeftHandSideExpression, or AssignmentPattern are non-nil, then
// AssignmentOperator must not be AssignmentNone and AssignmentExpression must
// be non-nil.
//
// If LeftHandSideArray, or LeftHandSideObject are non-nil, AssignmentOperator
// must be AssignmentAssign.
//
// If Yield is true, AssignmentExpression must be non-nil.
//
// It is only valid for Delegate to be true if Yield is also true.
//
// If AssignmentOperator is AssignmentNone LeftHandSideExpression must be nil.
//
// If LeftHandSideExpression, and AssignmentPattern are nil and Yield is false,
// AssignmentExpression must be nil.
type AssignmentExpression struct {
	ConditionalExpression  *ConditionalExpression
	ArrowFunction          *ArrowFunction
	LeftHandSideExpression *LeftHandSideExpression
	AssignmentPattern      *AssignmentPattern
	Yield                  bool
	Delegate               bool
	AssignmentOperator     AssignmentOperator
	AssignmentExpression   *AssignmentExpression
	Comments               [2]Comments
	Tokens                 Tokens
}

func (ae *AssignmentExpression) parse(j *jsParser, in, yield, await bool) error {
	done := false
	g := j.NewGoal()

	g.AcceptRunWhitespace()

	if yield && g.AcceptToken(parser.Token{Type: TokenKeyword, Data: "yield"}) {
		ae.Yield = true
		ae.Comments[0] = j.AcceptRunWhitespaceComments()

		j.AcceptRunWhitespace()
		j.Skip()

		j.AcceptRunWhitespaceNoComment()

		g = j.NewGoal()

		g.AcceptRunWhitespaceNoNewLine()

		if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "*"}) {
			ae.Delegate = true
			ae.Comments[1] = j.AcceptRunWhitespaceComments()

			j.AcceptRunWhitespaceNoNewLine()
			j.Skip()
			j.AcceptRunWhitespaceNoComment()
		}

		g := j.NewGoal()

		ae.AssignmentExpression = new(AssignmentExpression)
		if err := ae.AssignmentExpression.parse(&g, in, true, await); err != nil {
			return j.Error("AssignmentExpression", err)
		}

		j.Score(g)

		done = true
	} else if g.Peek() == (parser.Token{Type: TokenIdentifier, Data: "async"}) {
		g.Skip()
		g.AcceptRunWhitespaceNoNewLine()

		if g.SkipGeneric() {
			g.AcceptRunWhitespaceNoNewLine()
		}

		if t := g.Peek().Type; t == TokenPunctuator || t == TokenIdentifier {
			g = j.NewGoal()

			ae.ArrowFunction = new(ArrowFunction)
			if err := ae.ArrowFunction.parse(&g, in, yield, await); err != nil {
				return j.Error("AssignmentExpression", err)
			}

			j.Score(g)

			done = true
		}
	} else {
		g = j.NewGoal()

		g.AcceptRunWhitespace()

		if g.SkipGeneric() {
			g = j.NewGoal()

			ae.ArrowFunction = new(ArrowFunction)
			if err := ae.ArrowFunction.parse(&g, in, yield, await); err != nil {
				return j.Error("AssignmentExpression", err)
			}

			j.Score(g)

			done = true
		} else if g.Peek() == (parser.Token{Type: TokenPunctuator, Data: "("}) {
			g.SkipDepth()
			g.AcceptRunWhitespaceNoNewLine()

			if g.SkipReturnType() {
				g.AcceptRunWhitespaceNoNewLine()
			}

			if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "=>"}) {
				g = j.NewGoal()

				ae.ArrowFunction = new(ArrowFunction)
				if err := ae.ArrowFunction.parse(&g, in, yield, await); err != nil {
					return j.Error("AssignmentExpression", err)
				}

				j.Score(g)

				done = true
			}
		} else if g.Accept(TokenIdentifier) {
			g.AcceptRunWhitespaceNoNewLine()

			if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "=>"}) {
				g = j.NewGoal()

				ae.ArrowFunction = new(ArrowFunction)
				if err := ae.ArrowFunction.parse(&g, in, yield, await); err != nil {
					return j.Error("AssignmentExpression", err)
				}

				j.Score(g)

				done = true
			}
		}
	}

	if !done {
		g = j.NewGoal()

		ae.ConditionalExpression = new(ConditionalExpression)
		if err := ae.ConditionalExpression.parse(&g, in, yield, await); err != nil {
			return j.Error("AssignmentExpression", err)
		}

		if ae.ConditionalExpression.LogicalORExpression != nil {
			if lhs := ae.ConditionalExpression.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression; lhs != nil && len(ae.ConditionalExpression.Tokens) == len(lhs.Tokens) && (lhs.IsSimple() || lhs.isCoverAssignmentPattern()) {
				h := g.NewGoal()

				h.AcceptRunWhitespace()

				if err := ae.AssignmentOperator.parse(&h); err == nil {
					g.Score(h)
					g.AcceptRunWhitespaceNoComment()

					ae.ConditionalExpression = nil
					ae.LeftHandSideExpression = lhs

					if ae.AssignmentOperator == AssignmentAssign && lhs.isCoverAssignmentPattern() {
						ae.AssignmentPattern = new(AssignmentPattern)
						if err := ae.AssignmentPattern.from(&lhs.NewExpression.MemberExpression); err != nil {
							z := jsParser(lhs.Tokens[:0])

							return z.Error("AssignmentExpression", err)
						}

						ae.LeftHandSideExpression = nil
					}

					h = g.NewGoal()

					ae.AssignmentExpression = new(AssignmentExpression)
					if err := ae.AssignmentExpression.parse(&h, in, yield, await); err != nil {
						return g.Error("AssignmentExpression", err)
					}

					g.Score(h)
				}
			}
		}

		j.Score(g)
	}

	ae.Tokens = j.ToTokens()

	return nil
}

func (ae *AssignmentExpression) hasFirstComment() bool {
	if ae.ConditionalExpression != nil {
		return ae.ConditionalExpression.hasFirstComment()
	}

	if ae.AssignmentPattern != nil {
		return ae.AssignmentPattern.hasFirstComment()
	}

	if ae.LeftHandSideExpression != nil {
		return ae.LeftHandSideExpression.hasFirstComment()
	}

	if ae.ArrowFunction != nil {
		return ae.ArrowFunction.hasFirstComment()
	}

	return false
}

func (ae *AssignmentExpression) hasSingleLineComment() bool {
	return ae != nil && (hasSingleLineComment(ae.Comments[:]) || ae.ConditionalExpression.hasSingleLineComment() || ae.AssignmentPattern.hasSingleLineComment() || ae.LeftHandSideExpression.hasSingleLineComment() || ae.ArrowFunction.hasSingleLineComment())
}

// LeftHandSideExpression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-LeftHandSideExpression
//
// It is only valid for one of NewExpression, CallExpression or
// OptionalExpression to be non-nil.
//
// Includes OptionalExpression as per TC39 (2020-03)
type LeftHandSideExpression struct {
	NewExpression      *NewExpression
	CallExpression     *CallExpression
	OptionalExpression *OptionalExpression
	Comments           Comments
	Tokens             Tokens
}

func (lhs *LeftHandSideExpression) parse(j *jsParser, yield, await bool) error {
	g := j.NewGoal()

	if g.AcceptToken(parser.Token{Type: TokenKeyword, Data: "super"}) || g.AcceptToken(parser.Token{Type: TokenKeyword, Data: "import"}) {
		g.AcceptRunWhitespace()

		if g.Peek() == (parser.Token{Type: TokenPunctuator, Data: "("}) {
			g = j.NewGoal()

			lhs.CallExpression = new(CallExpression)
			if err := lhs.CallExpression.parse(&g, nil, yield, await); err != nil {
				return j.Error("LeftHandSideExpression", err)
			}

			j.Score(g)
		}
	}

	if lhs.CallExpression == nil {
		g = j.NewGoal()

		lhs.NewExpression = new(NewExpression)
		if err := lhs.NewExpression.parse(&g, yield, await); err != nil {
			return j.Error("LeftHandSideExpression", err)
		}

		if len(lhs.NewExpression.News) == 0 {
			h := g.NewGoal()

			h.AcceptRunWhitespace()

			if h.SkipTypeArguments() {
				h.AcceptRunWhitespace()
			}

			if h.Peek() == (parser.Token{Type: TokenPunctuator, Data: "("}) {
				lhs.CallExpression = new(CallExpression)

				if err := lhs.CallExpression.parse(&g, &lhs.NewExpression.MemberExpression, yield, await); err != nil {
					return j.Error("LeftHandSideExpression", err)
				}

				lhs.NewExpression = nil
			}
		}

		j.Score(g)
	}

	g = j.NewGoal()

	g.AcceptRunWhitespace()

	if g.Peek() == (parser.Token{Type: TokenPunctuator, Data: "?."}) {
		if lhs.CallExpression != nil {
			g = j.NewGoal()

			j.AcceptRunWhitespace()

			lhs.OptionalExpression = new(OptionalExpression)
			if err := lhs.OptionalExpression.parse(j, yield, await, nil, lhs.CallExpression); err != nil {
				return g.Error("LeftHandSideExpression", err)
			}

			lhs.CallExpression = nil
		} else if len(lhs.NewExpression.News) == 0 {
			g = j.NewGoal()

			j.AcceptRunWhitespace()

			lhs.OptionalExpression = new(OptionalExpression)
			if err := lhs.OptionalExpression.parse(j, yield, await, &lhs.NewExpression.MemberExpression, nil); err != nil {
				return g.Error("LeftHandSideExpression", err)
			}

			lhs.NewExpression = nil
		}
	}

	g = j.NewGoal()

	g.AcceptRunWhitespace()

	h := g.NewGoal()

	if h.SkipAsType() {
		for {
			i := h.NewGoal()

			i.AcceptRunWhitespace()

			if i.SkipAsType() {
				h.Score(i)
			} else {
				break
			}
		}

		lhs.Comments = append(lhs.Comments, h.ToTypescriptComments()...)

		g.Score(h)
		j.Score(g)

		lhs.Comments = append(lhs.Comments, j.AcceptRunWhitespaceCommentsInList()...)
	}

	lhs.Tokens = j.ToTokens()

	return nil
}

// IsSimple returns whether or not the LeftHandSideExpression is classed as 'simple'
func (lhs *LeftHandSideExpression) IsSimple() bool {
	return lhs.OptionalExpression == nil && (lhs.NewExpression != nil && len(lhs.NewExpression.News) == 0 && lhs.NewExpression.MemberExpression.IsSimple() || lhs.CallExpression != nil && lhs.CallExpression.IsSimple())
}

func (lhs *LeftHandSideExpression) isCoverAssignmentPattern() bool {
	return lhs.NewExpression != nil && len(lhs.NewExpression.News) == 0 && lhs.NewExpression.MemberExpression.PrimaryExpression != nil && (lhs.NewExpression.MemberExpression.PrimaryExpression.ArrayLiteral != nil || lhs.NewExpression.MemberExpression.PrimaryExpression.ObjectLiteral != nil)
}

func (lhs *LeftHandSideExpression) hasFirstComment() bool {
	if lhs.NewExpression != nil {
		return lhs.NewExpression.hasFirstComment()
	}

	if lhs.CallExpression != nil {
		return lhs.CallExpression.hasFirstComment()
	}

	if lhs.OptionalExpression != nil {
		return lhs.OptionalExpression.hasFirstComment()
	}

	return false
}

func (lhs *LeftHandSideExpression) hasSingleLineComment() bool {
	return lhs != nil && (lhs.Comments.hasSingleLineComment() || lhs.NewExpression.hasSingleLineComment() || lhs.CallExpression.hasSingleLineComment() || lhs.OptionalExpression.hasSingleLineComment())
}

// AssignmentPattern as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-AssignmentPattern
//
// Only one of ObjectAssignmentPattern or ArrayAssignmentPattern must be
// non-nil
type AssignmentPattern struct {
	ObjectAssignmentPattern *ObjectAssignmentPattern
	ArrayAssignmentPattern  *ArrayAssignmentPattern
	Comments                [2]Comments
	Tokens                  Tokens
}

func (a *AssignmentPattern) from(me *MemberExpression) error {
	p := me.PrimaryExpression

	if p.ArrayLiteral != nil {
		a.ArrayAssignmentPattern = new(ArrayAssignmentPattern)
		if err := a.ArrayAssignmentPattern.from(p.ArrayLiteral); err != nil {
			z := jsParser(p.ArrayLiteral.Tokens[:0])

			return z.Error("AssignmentPattern", err)
		}
	} else {
		a.ObjectAssignmentPattern = new(ObjectAssignmentPattern)
		if err := a.ObjectAssignmentPattern.from(p.ObjectLiteral); err != nil {
			z := jsParser(p.ObjectLiteral.Tokens[:0])

			return z.Error("AssignmentPattern", err)
		}
	}

	a.Comments[0] = me.Comments[0]
	a.Comments[1] = me.Comments[4]
	a.Tokens = me.Tokens

	return nil
}

func (a *AssignmentPattern) hasFirstComment() bool {
	return len(a.Comments[0]) > 0
}

func (a *AssignmentPattern) hasSingleLineComment() bool {
	return a != nil && hasSingleLineComment(a.Comments[:])
}

// ObjectAssignmentPattern as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-ObjectAssignmentPattern
type ObjectAssignmentPattern struct {
	AssignmentPropertyList []AssignmentProperty
	AssignmentRestElement  *LeftHandSideExpression
	Comments               [3]Comments
	Tokens                 Tokens
}

func (o *ObjectAssignmentPattern) from(ol *ObjectLiteral) error {
	o.AssignmentPropertyList = make([]AssignmentProperty, len(ol.PropertyDefinitionList))

	for n := range ol.PropertyDefinitionList {
		pd := &ol.PropertyDefinitionList[n]

		if pd.PropertyName == nil && pd.AssignmentExpression != nil {
			if n == len(ol.PropertyDefinitionList)-1 {
				o.AssignmentPropertyList = o.AssignmentPropertyList[:n:n]

				var dat DestructuringAssignmentTarget

				if pd.AssignmentExpression.AssignmentOperator != AssignmentNone {
					z := jsParser(pd.AssignmentExpression.Tokens[:0])

					return z.Error("ObjectAssignmentPattern", ErrInvalidAssignment)
				}

				if err := dat.from(pd.AssignmentExpression); err != nil {
					z := jsParser(pd.AssignmentExpression.Tokens[:0])

					return z.Error("ObjectAssignmentPattern", err)
				}

				if dat.AssignmentPattern != nil {
					z := jsParser(dat.Tokens[:0])

					return z.Error("ObjectAssignmentPattern", ErrBadRestElement)
				}

				o.Comments[1] = pd.Comments[0]
				o.AssignmentRestElement = dat.LeftHandSideExpression

				break
			}
		}

		if err := o.AssignmentPropertyList[n].from(pd); err != nil {
			z := jsParser(pd.Tokens[:0])

			return z.Error("ObjectAssignmentPattern", err)
		}
	}

	o.Comments[0] = ol.Comments[0]
	o.Comments[2] = ol.Comments[1]
	o.Tokens = ol.Tokens

	return nil
}

func (o *ObjectAssignmentPattern) hasSingleLineComment() bool {
	return o != nil && (hasSingleLineComment(o.Comments[:]) || hasSingleLineComment(o.AssignmentPropertyList) || o.AssignmentRestElement.hasSingleLineComment())
}

// AssignmentProperty as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-AssignmentProperty
type AssignmentProperty struct {
	PropertyName                  PropertyName
	DestructuringAssignmentTarget *DestructuringAssignmentTarget
	Initializer                   *AssignmentExpression
	Comments                      [2]Comments
	Tokens                        Tokens
}

func (a *AssignmentProperty) from(pd *PropertyDefinition) error {
	if pd.MethodDefinition != nil || pd.PropertyName == nil {
		z := jsParser(pd.Tokens[:0])

		return z.Error("AssignmentProperty", ErrInvalidAssignmentProperty)
	}

	if pd.PropertyName.LiteralPropertyName == nil {
		z := jsParser(pd.Tokens[:0])

		return z.Error("AssignmentProperty", z.Error("PropertyName", ErrNotSimple))
	}

	a.PropertyName = *pd.PropertyName

	if pd.IsCoverInitializedName {
		a.DestructuringAssignmentTarget = &DestructuringAssignmentTarget{
			LeftHandSideExpression: &LeftHandSideExpression{
				NewExpression: &NewExpression{
					MemberExpression: MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &Token{
								Token:   a.PropertyName.LiteralPropertyName.Token,
								Pos:     a.PropertyName.LiteralPropertyName.Pos,
								Line:    a.PropertyName.LiteralPropertyName.Line,
								LinePos: a.PropertyName.LiteralPropertyName.LinePos,
							},
							Tokens: a.PropertyName.Tokens,
						},
						Tokens: a.PropertyName.Tokens,
					},
					Tokens: a.PropertyName.Tokens,
				},
				Tokens: a.PropertyName.Tokens,
			},
			Tokens: a.PropertyName.Tokens,
		}

		a.Initializer = pd.AssignmentExpression
	} else {
		a.DestructuringAssignmentTarget = new(DestructuringAssignmentTarget)
		if err := a.DestructuringAssignmentTarget.from(pd.AssignmentExpression); err != nil {
			z := jsParser(pd.Tokens[:0])

			return z.Error("AssignmentProperty", err)
		}

		a.Initializer = pd.AssignmentExpression.AssignmentExpression
	}

	a.Comments = pd.Comments
	a.Tokens = pd.Tokens

	return nil
}

func (a *AssignmentProperty) hasSingleLineComment() bool {
	return a != nil && (hasSingleLineComment(a.Comments[:]) || a.DestructuringAssignmentTarget.hasSingleLineComment() || a.Initializer.hasSingleLineComment())
}

// DestructuringAssignmentTarget as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-DestructuringAssignmentTarget
//
// Only one of LeftHandSideExpression or AssignmentPattern must be non-nil
type DestructuringAssignmentTarget struct {
	LeftHandSideExpression *LeftHandSideExpression
	AssignmentPattern      *AssignmentPattern
	Tokens                 Tokens
}

func (d *DestructuringAssignmentTarget) from(ae *AssignmentExpression) error {
	if ae.LeftHandSideExpression != nil {
		d.LeftHandSideExpression = ae.LeftHandSideExpression
		d.Tokens = ae.LeftHandSideExpression.Tokens
	} else if ae.AssignmentPattern != nil {
		d.AssignmentPattern = ae.AssignmentPattern
		d.Tokens = ae.AssignmentPattern.Tokens
	} else if ae.ConditionalExpression == nil {
		z := jsParser(ae.Tokens[:0])

		return z.Error("DestructuringAssignmentTarget", ErrInvalidDestructuringAssignmentTarget)
	} else {
		switch UnwrapConditional(ae.ConditionalExpression).(type) {
		case *ArrayLiteral, *ObjectLiteral:
			d.AssignmentPattern = new(AssignmentPattern)
			if err := d.AssignmentPattern.from(&ae.ConditionalExpression.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression.NewExpression.MemberExpression); err != nil {
				z := jsParser(ae.Tokens[:0])

				return z.Error("DestructuringAssignmentTarget", err)
			}
		case *CallExpression, *MemberExpression, *PrimaryExpression:
			d.LeftHandSideExpression = ae.ConditionalExpression.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression
			if !d.LeftHandSideExpression.IsSimple() {
				z := jsParser(ae.Tokens[:0])

				return z.Error("DestructuringAssignmentTarget", ErrInvalidDestructuringAssignmentTarget)
			}
		default:
			z := jsParser(ae.Tokens[:0])

			return z.Error("DestructuringAssignmentTarget", ErrInvalidDestructuringAssignmentTarget)
		}

		d.Tokens = ae.ConditionalExpression.Tokens
	}

	return nil
}

func (d *DestructuringAssignmentTarget) hasSingleLineComment() bool {
	return d != nil && (d.LeftHandSideExpression.hasSingleLineComment() || d.AssignmentPattern.hasSingleLineComment())
}

// AssignmentElement as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-AssignmentElement
type AssignmentElement struct {
	DestructuringAssignmentTarget DestructuringAssignmentTarget
	Initializer                   *AssignmentExpression
	Tokens                        Tokens
}

func (a *AssignmentElement) from(ae *AssignmentExpression) error {
	switch ae.AssignmentOperator {
	case AssignmentNone, AssignmentAssign:
		if err := a.DestructuringAssignmentTarget.from(ae); err != nil {
			z := jsParser(ae.Tokens[:0])

			return z.Error("AssignmentElement", err)
		}

		a.Initializer = ae.AssignmentExpression
	default:
		z := jsParser(ae.Tokens[:0])

		return z.Error("AssignmentElement", ErrInvalidAssignment)
	}

	a.Tokens = ae.Tokens

	return nil
}

func (a *AssignmentElement) hasSingleLineComment() bool {
	return a.DestructuringAssignmentTarget.hasSingleLineComment() || a.Initializer.hasSingleLineComment()
}

// ArrayAssignmentPattern as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-ArrayAssignmentPattern
type ArrayAssignmentPattern struct {
	AssignmentElements    []AssignmentElement
	AssignmentRestElement *LeftHandSideExpression
	Comments              [3]Comments
	Tokens                Tokens
}

func (a *ArrayAssignmentPattern) from(al *ArrayLiteral) error {
	a.AssignmentElements = make([]AssignmentElement, 0, len(al.ElementList))
	hasSpread := false

	for _, ae := range al.ElementList {
		if hasSpread {
			z := jsParser(al.Tokens[:0])

			return z.Error("ArrayAssignmentPattern", ErrBadRestElement)
		} else if ae.Spread {
			hasSpread = true

			var dat DestructuringAssignmentTarget

			if ae.AssignmentExpression.AssignmentOperator != AssignmentNone {
				z := jsParser(al.Tokens[:0])

				return z.Error("ArrayAssignmentPattern", ErrInvalidAssignment)
			}

			if err := dat.from(&ae.AssignmentExpression); err != nil {
				z := jsParser(al.Tokens[:0])

				return z.Error("ArrayAssignmentPattern", err)
			}

			if dat.AssignmentPattern != nil {
				z := jsParser(al.Tokens[:0])

				return z.Error("ArrayAssignmentPattern", ErrBadRestElement)
			}

			a.Comments[1] = ae.Comments
			a.AssignmentRestElement = dat.LeftHandSideExpression
		} else if len(ae.Tokens) > 0 {
			var e AssignmentElement

			if err := e.from(&ae.AssignmentExpression); err != nil {
				z := jsParser(al.Tokens[:0])

				return z.Error("ArrayAssignmentPattern", err)
			}

			a.AssignmentElements = append(a.AssignmentElements, e)
		} else {
			a.AssignmentElements = append(a.AssignmentElements, AssignmentElement{})
		}
	}

	a.Comments[0] = al.Comments[0]
	a.Comments[2] = al.Comments[1]
	a.Tokens = al.Tokens

	return nil
}

func (a *ArrayAssignmentPattern) hasSingleLineComment() bool {
	return a != nil && (hasSingleLineComment(a.Comments[:]) || hasSingleLineComment(a.AssignmentElements) || a.AssignmentRestElement.hasSingleLineComment())
}

// OptionalExpression as defined in TC39
// https://tc39.es/ecma262/#prod-OptionalExpression
//
// It is only valid for one of NewExpression, CallExpression or
// OptionalExpression to be non-nil.
type OptionalExpression struct {
	MemberExpression   *MemberExpression
	CallExpression     *CallExpression
	OptionalExpression *OptionalExpression
	OptionalChain      OptionalChain
	Tokens             Tokens
}

func (oe *OptionalExpression) parse(j *jsParser, yield, await bool, me *MemberExpression, ce *CallExpression) error {
	if me != nil {
		oe.MemberExpression = me
	} else {
		oe.CallExpression = ce
	}

	g := j.NewGoal()

	if err := oe.OptionalChain.parse(&g, yield, await); err != nil {
		return j.Error("OptionalExpression", err)
	}

	for {
		j.Score(g)

		oe.Tokens = j.ToTokens()
		g = j.NewGoal()

		g.AcceptRunWhitespace()

		if g.Peek() != (parser.Token{Type: TokenPunctuator, Data: "?."}) {
			break
		}

		noe := new(OptionalExpression)
		*noe = *oe
		*oe = OptionalExpression{OptionalExpression: noe}
		h := g.NewGoal()

		if err := oe.OptionalChain.parse(&h, yield, await); err != nil {
			return g.Error("OptionalExpression", err)
		}

		g.Score(h)
	}

	return nil
}

func (oe *OptionalExpression) hasFirstComment() bool {
	if oe.MemberExpression != nil {
		return oe.MemberExpression.hasFirstComment()
	}

	if oe.CallExpression != nil {
		return oe.CallExpression.hasFirstComment()
	}

	if oe.OptionalExpression != nil {
		return oe.OptionalExpression.hasFirstComment()
	}

	return false
}

func (oe *OptionalExpression) hasSingleLineComment() bool {
	return oe != nil && (oe.MemberExpression.hasSingleLineComment() || oe.CallExpression.hasSingleLineComment() || oe.OptionalExpression.hasSingleLineComment())
}

// OptionalChain as defined in TC39
// https://tc39.es/ecma262/#prod-OptionalExpression
//
// It is only valid for one of Arguments, Expression, IdentifierName,
// TemplateLiteral, or PrivateIdentifier to be non-nil.
type OptionalChain struct {
	OptionalChain     *OptionalChain
	Arguments         *Arguments
	Expression        *Expression
	IdentifierName    *Token
	TemplateLiteral   *TemplateLiteral
	PrivateIdentifier *Token
	Comments          [4]Comments
	Tokens            Tokens
}

func (oc *OptionalChain) parse(j *jsParser, yield, await bool) error {
	if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "?."}) {
		return j.Error("OptionalChain", ErrMissingOptional)
	}

	oc.Comments[0] = j.AcceptRunWhitespaceComments()

	j.AcceptRunWhitespace()

	g := j.NewGoal()

	var c Comments

	if g.SkipTypeArguments() {
		c = g.ToTypescriptComments()
		c = append(c, g.AcceptRunWhitespaceComments()...)

		g.AcceptRunWhitespace()
	}

	if g.Peek() == (parser.Token{Type: TokenPunctuator, Data: "("}) {
		oc.Comments[0] = append(oc.Comments[0], c...)
		h := g.NewGoal()

		oc.Arguments = new(Arguments)
		if err := oc.Arguments.parse(&h, yield, await); err != nil {
			return j.Error("OptionalChain", err)
		}

		g.Score(h)
		j.Score(g)
	} else if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "["}) {
		oc.Comments[1] = j.AcceptRunWhitespaceNoNewlineComments()

		j.AcceptRunWhitespaceNoComment()

		g := j.NewGoal()

		oc.Expression = new(Expression)
		if err := oc.Expression.parse(&g, true, yield, await); err != nil {
			return j.Error("OptionalChain", err)
		}

		oc.Comments[2] = g.AcceptRunWhitespaceComments()
		g.AcceptRunWhitespace()

		if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "]"}) {
			return g.Error("OptionalChain", ErrMissingClosingBracket)
		}

		j.Score(g)
	} else if j.Accept(TokenIdentifier, TokenKeyword) {
		oc.IdentifierName = j.GetLastToken()
	} else if j.Accept(TokenPrivateIdentifier) {
		oc.PrivateIdentifier = j.GetLastToken()
	} else if t := j.Peek().Type; t == TokenNoSubstitutionTemplate || t == TokenTemplateHead {
		g := j.NewGoal()

		oc.TemplateLiteral = new(TemplateLiteral)
		if err := oc.TemplateLiteral.parse(&g, yield, await); err != nil {
			return j.Error("OptionalChain", err)
		}

		j.Score(g)
	} else {
		return j.Error("OptionalChain", ErrInvalidOptionalChain)
	}

	oc.Comments[3] = j.AcceptRunWhitespaceCommentsInList()

	g = j.NewGoal()

	g.AcceptRunWhitespaceNoNewLine()

	h := g.NewGoal()

	if h.SkipForce() {
		oc.Comments[3] = append(oc.Comments[3], h.ToTypescriptComments()...)
		oc.Comments[3] = append(oc.Comments[3], h.AcceptRunWhitespaceCommentsInList()...)

		g.Score(h)
		j.Score(g)
	}

	for {
		oc.Tokens = j.ToTokens()
		g := j.NewGoal()

		g.AcceptRunWhitespace()

		var (
			arguments         *Arguments
			expression        *Expression
			identifierName    *Token
			templateLiteral   *TemplateLiteral
			privateIdentifier *Token
			b, c, d, e        Comments
		)

		h := g.NewGoal()

		if h.SkipTypeArguments() {
			b = append(h.ToTypescriptComments(), h.AcceptRunWhitespaceComments()...)
			h.AcceptRunWhitespace()
		}

		if h.Peek() == (parser.Token{Type: TokenPunctuator, Data: "("}) {
			i := h.NewGoal()

			arguments = new(Arguments)
			if err := arguments.parse(&i, yield, await); err != nil {
				return g.Error("OptionalChain", err)
			}

			h.Score(i)
			g.Score(h)
		} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "["}) {
			b = nil
			c = g.AcceptRunWhitespaceNoNewlineComments()

			g.AcceptRunWhitespaceNoComment()

			h = g.NewGoal()

			expression = new(Expression)
			if err := expression.parse(&h, true, yield, await); err != nil {
				return g.Error("OptionalChain", err)
			}

			d = h.AcceptRunWhitespaceComments()
			h.AcceptRunWhitespace()

			if !h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "]"}) {
				return h.Error("OptionalChain", ErrMissingClosingBracket)
			}

			g.Score(h)
		} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "."}) {
			b = nil
			c = g.AcceptRunWhitespaceComments()

			g.AcceptRunWhitespace()

			if g.Accept(TokenPrivateIdentifier) {
				privateIdentifier = g.GetLastToken()
			} else {
				if !g.Accept(TokenIdentifier, TokenKeyword) {
					return g.Error("OptionalChain", ErrNoIdentifier)
				}

				identifierName = g.GetLastToken()
			}
		} else if t := g.Peek().Type; t == TokenNoSubstitutionTemplate || t == TokenTemplateHead {
			b = nil
			h := g.NewGoal()

			templateLiteral = new(TemplateLiteral)
			if err := templateLiteral.parse(&h, yield, await); err != nil {
				return g.Error("OptionalChain", err)
			}

			g.Score(h)
		} else {
			break
		}

		e = g.AcceptRunWhitespaceCommentsInList()
		h = g.NewGoal()

		h.AcceptRunWhitespaceNoNewLine()

		i := h.NewGoal()

		if i.SkipForce() {
			e = append(e, i.ToTypescriptComments()...)
			e = append(e, i.AcceptRunWhitespaceCommentsInList()...)

			h.Score(i)
			g.Score(h)
		}

		noc := new(OptionalChain)
		*noc = *oc
		*oc = OptionalChain{
			Arguments:         arguments,
			Expression:        expression,
			IdentifierName:    identifierName,
			TemplateLiteral:   templateLiteral,
			PrivateIdentifier: privateIdentifier,
			OptionalChain:     noc,
			Comments:          [4]Comments{b, c, d, e},
		}

		j.Score(g)
	}

	return nil
}

// Expression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-Expression
//
// Expressions must have a length of at least one to be valid.
type Expression struct {
	Expressions []AssignmentExpression
	Tokens      Tokens
}

func (e *Expression) parse(j *jsParser, in, yield, await bool) error {
	for {
		g := j.NewGoal()
		ae := len(e.Expressions)

		e.Expressions = append(e.Expressions, AssignmentExpression{})
		if err := e.Expressions[ae].parse(&g, in, yield, await); err != nil {
			return j.Error("Expression", err)
		}

		j.Score(g)

		g = j.NewGoal()

		g.AcceptRunWhitespace()

		if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ","}) {
			break
		}

		g.AcceptRunWhitespaceNoComment()
		j.Score(g)
	}

	e.Tokens = j.ToTokens()

	return nil
}

func (e *Expression) hasFirstComment() bool {
	if len(e.Expressions) == 0 {
		return false
	}

	return e.Expressions[0].hasFirstComment()
}

func (e *Expression) hasSingleLineComment() bool {
	if e == nil {
		return false
	}

	for _, ae := range e.Expressions {
		if ae.hasSingleLineComment() {
			return true
		}
	}

	return false
}

// NewExpression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-NewExpression
//
// The News field is a count of the number of 'new' keywords that proceed the
// MemberExpression
type NewExpression struct {
	News             []Comments
	MemberExpression MemberExpression
	Tokens           Tokens
}

func (ne *NewExpression) parse(j *jsParser, yield, await bool) error {
	g := j.NewGoal()

	if err := ne.MemberExpression.parse(&g, yield, await); err != nil {
		h := j.NewGoal()

		for {
			h.AcceptRunWhitespace()

			if ne.MemberExpression.MemberExpression == nil || !h.AcceptToken(parser.Token{Type: TokenKeyword, Data: "new"}) {
				return j.Error("NewExpression", err)
			}

			ne.News = append(ne.News, ne.MemberExpression.Comments[0])
			ne.MemberExpression = *ne.MemberExpression.MemberExpression

			if ne.MemberExpression.Tokens != nil {
				break
			}
		}
	}

	j.Score(g)

	ne.Tokens = j.ToTokens()

	return nil
}

func (ne *NewExpression) hasFirstComment() bool {
	if len(ne.News) == 0 {
		return ne.MemberExpression.hasFirstComment()
	}

	return len(ne.News[0]) > 0
}

func (ne *NewExpression) hasSingleLineComment() bool {
	return ne != nil && (hasSingleLineComment(ne.News) || ne.MemberExpression.hasSingleLineComment())
}

// MemberExpression as defined in ECMA-262
// https://tc39.es/ecma262/#prod-MemberExpression
//
// If PrimaryExpression is nil, SuperProperty is true, NewTarget is true, or
// ImportMeta is true, Expression, IdentifierName, TemplateLiteral, Arguments
// and PrivateIdentifier must be nil.
//
// If Expression, IdentifierName, TemplateLiteral, Arguments, or
// PrivateIdentifier is non-nil, then MemberExpression must be non-nil.
//
// It is only valid if one of Expression, IdentifierName, TemplateLiteral,
// Arguments, and PrivateIdentifier is non-nil.
type MemberExpression struct {
	MemberExpression  *MemberExpression
	PrimaryExpression *PrimaryExpression
	Expression        *Expression
	IdentifierName    *Token
	TemplateLiteral   *TemplateLiteral
	SuperProperty     bool
	NewTarget         bool
	ImportMeta        bool
	Arguments         *Arguments
	PrivateIdentifier *Token
	Comments          [5]Comments
	Tokens            Tokens
}

func (me *MemberExpression) parse(j *jsParser, yield, await bool) error {
	me.Comments[0] = j.AcceptRunWhitespaceComments()

	j.AcceptRunWhitespace()

	g := j.NewGoal()
	e := false

	if g.AcceptToken(parser.Token{Type: TokenKeyword, Data: "super"}) {
		me.Comments[1] = g.AcceptRunWhitespaceComments()

		g.AcceptRunWhitespace()

		if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "["}) {
			me.Comments[2] = g.AcceptRunWhitespaceNoNewlineComments()

			g.AcceptRunWhitespaceNoComment()

			h := g.NewGoal()

			me.Expression = new(Expression)
			if err := me.Expression.parse(&h, true, yield, await); err != nil {
				return g.Error("MemberExpression", err)
			}

			g.Score(h)

			me.Comments[3] = g.AcceptRunWhitespaceComments()

			g.AcceptRunWhitespace()

			if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "]"}) {
				return g.Error("MemberExpression", ErrInvalidSuperProperty)
			}
		} else if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "."}) {
			me.Comments[2] = g.AcceptRunWhitespaceComments()

			g.AcceptRunWhitespace()

			if !g.Accept(TokenIdentifier, TokenKeyword) {
				return g.Error("MemberExpression", ErrNoIdentifier)
			}

			me.IdentifierName = g.GetLastToken()
		} else {
			return g.Error("MemberExpression", ErrInvalidSuperProperty)
		}

		me.SuperProperty = true
	} else if g.Peek() == (parser.Token{Type: TokenKeyword, Data: "new"}) || g.Peek() == (parser.Token{Type: TokenKeyword, Data: "import"}) {
		var isNew bool

		if g.Peek().Data == "new" {
			isNew = true
		}

		g.Skip()
		g.AcceptRunWhitespace()

		if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "."}) {
			g = j.NewGoal()

			g.Skip()

			me.Comments[1] = g.AcceptRunWhitespaceComments()

			g.AcceptRunWhitespace()
			g.Skip()

			me.Comments[2] = g.AcceptRunWhitespaceComments()

			g.AcceptRunWhitespace()

			var id string

			if isNew {
				id = "target"
				me.NewTarget = true
			} else {
				id = "meta"
				me.ImportMeta = true
			}

			if !g.AcceptToken(parser.Token{Type: TokenIdentifier, Data: id}) {
				return j.Error("MemberExpression", ErrInvalidMetaProperty)
			}
		} else if isNew {
			g = j.NewGoal()

			g.Skip()
			g.AcceptRunWhitespaceNoComment()

			h := g.NewGoal()

			me.MemberExpression = new(MemberExpression)
			if err := me.MemberExpression.parse(&h, yield, await); err != nil {
				err = j.Error("MemberExpression", err)

				g.Score(h)
				j.Score(g)

				return err
			}

			i := h.NewGoal()

			i.AcceptRunWhitespace()

			k := i.NewGoal()

			if k.SkipTypeArguments() {
				me.MemberExpression.Comments[4] = append(me.MemberExpression.Comments[4], k.ToTypescriptComments()...)
				me.MemberExpression.Comments[4] = append(me.MemberExpression.Comments[4], k.AcceptRunWhitespaceCommentsInList()...)

				i.Score(k)
				h.Score(i)

				me.MemberExpression.Tokens = h.ToTokens()
			}

			g.Score(h)

			h = g.NewGoal()

			h.AcceptRunWhitespace()

			i = h.NewGoal()

			me.Arguments = new(Arguments)
			if err := me.Arguments.parse(&i, yield, await); err != nil {
				j.Score(g)

				return g.Error("MemberExpression", err)
			}

			h.Score(i)
			g.Score(h)
		} else {
			g = j.NewGoal()
			e = true
		}
	} else {
		e = true
	}

	if e {
		me.PrimaryExpression = new(PrimaryExpression)
		if err := me.PrimaryExpression.parse(&g, yield, await); err != nil {
			return j.Error("MemberExpression", err)
		}

		h := g.NewGoal()

		h.AcceptRunWhitespaceNoNewLine()

		i := h.NewGoal()

		if i.SkipForce() {
			me.Comments[4] = i.ToTypescriptComments()

			h.Score(i)
			g.Score(h)
		}
	}

	j.Score(g)

	for {
		me.Comments[4] = append(me.Comments[4], j.AcceptRunWhitespaceCommentsInList()...)
		me.Tokens = j.ToTokens()
		g := j.NewGoal()

		g.AcceptRunWhitespace()

		h := g.NewGoal()

		var (
			tl      *TemplateLiteral
			i, p    *Token
			e       *Expression
			c, d, f Comments
		)

		switch tk := h.Peek(); tk.Type {
		case TokenNoSubstitutionTemplate, TokenTemplateHead:
			tl = new(TemplateLiteral)
			if err := tl.parse(&h, yield, await); err != nil {
				return g.Error("MemberExpression", err)
			}
		case TokenPunctuator:
			switch tk.Data {
			case ".":
				h.Skip()

				c = h.AcceptRunWhitespaceComments()

				h.AcceptRunWhitespace()

				if !h.Accept(TokenIdentifier, TokenKeyword, TokenPrivateIdentifier) {
					return g.Error("MemberExpression", ErrNoIdentifier)
				}

				if i = h.GetLastToken(); i.Type == TokenPrivateIdentifier {
					p = i
					i = nil
				}
			case "[":
				h.Skip()

				c = h.AcceptRunWhitespaceNoNewlineComments()

				h.AcceptRunWhitespaceNoComment()

				i := h.NewGoal()

				e = new(Expression)
				if err := e.parse(&i, true, yield, await); err != nil {
					return g.Error("MemberExpression", err)
				}

				h.Score(i)

				d = h.AcceptRunWhitespaceComments()

				h.AcceptRunWhitespace()

				if !h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "]"}) {
					return g.Error("MemberExpression", ErrMissingClosingBracket)
				}
			default:
				return nil
			}

			i := h.NewGoal()

			i.AcceptRunWhitespaceNoNewLine()

			k := i.NewGoal()

			if k.SkipForce() {
				f = k.ToTypescriptComments()

				i.Score(k)
				h.Score(i)
			}
		default:
			return nil
		}

		g.Score(h)

		nme := new(MemberExpression)
		*nme = *me
		*me = MemberExpression{
			MemberExpression:  nme,
			Expression:        e,
			IdentifierName:    i,
			TemplateLiteral:   tl,
			PrivateIdentifier: p,
			Comments:          [5]Comments{nil, c, d, nil, f},
		}

		j.Score(g)
	}
}

// IsSimple returns whether or not the MemberExpression is classed as 'simple'
func (me *MemberExpression) IsSimple() bool {
	return me.Expression != nil || me.IdentifierName != nil || me.SuperProperty || me.PrivateIdentifier != nil || (me.PrimaryExpression != nil && me.PrimaryExpression.IsSimple())
}

func (me *MemberExpression) hasFirstComment() bool {
	if me.MemberExpression != nil {
		return me.MemberExpression.hasFirstComment()
	}

	return len(me.Comments[0]) > 0
}

func (me *MemberExpression) hasSingleLineComment() bool {
	return me != nil && (hasSingleLineComment(me.Comments[:]) || me.MemberExpression.hasSingleLineComment())
}

// PrimaryExpression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-PrimaryExpression
//
// It is only valid is one IdentifierReference, Literal, ArrayLiteral,
// ObjectLiteral, FunctionExpression, ClassExpression, TemplateLiteral, or
// ParenthesizedExpression is non-nil or This is true.
type PrimaryExpression struct {
	This                    *Token
	IdentifierReference     *Token
	Literal                 *Token
	ArrayLiteral            *ArrayLiteral
	ObjectLiteral           *ObjectLiteral
	FunctionExpression      *FunctionDeclaration
	ClassExpression         *ClassDeclaration
	TemplateLiteral         *TemplateLiteral
	ParenthesizedExpression *ParenthesizedExpression
	JSXElement              *JSXElement
	JSXFragment             *JSXFragment
	Tokens                  Tokens
}

func (pe *PrimaryExpression) parse(j *jsParser, yield, await bool) error {
	if j.AcceptToken(parser.Token{Type: TokenKeyword, Data: "this"}) {
		pe.This = j.GetLastToken()
	} else if j.Accept(TokenNullLiteral, TokenBooleanLiteral, TokenNumericLiteral, TokenStringLiteral, TokenRegularExpressionLiteral) {
		pe.Literal = j.GetLastToken()
	} else if t := j.Peek(); t == (parser.Token{Type: TokenPunctuator, Data: "["}) {
		g := j.NewGoal()

		pe.ArrayLiteral = new(ArrayLiteral)
		if err := pe.ArrayLiteral.parse(&g, yield, await); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t == (parser.Token{Type: TokenPunctuator, Data: "{"}) {
		g := j.NewGoal()

		pe.ObjectLiteral = new(ObjectLiteral)
		if err := pe.ObjectLiteral.parse(&g, yield, await); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t == (parser.Token{Type: TokenIdentifier, Data: "async"}) || t == (parser.Token{Type: TokenKeyword, Data: "function"}) {
		g := j.NewGoal()

		pe.FunctionExpression = new(FunctionDeclaration)
		if err := pe.FunctionExpression.parse(&g, false, false, true, false); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t == (parser.Token{Type: TokenKeyword, Data: "class"}) {
		g := j.NewGoal()

		pe.ClassExpression = new(ClassDeclaration)
		if err := pe.ClassExpression.parse(&g, yield, await, true); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t.Type == TokenNoSubstitutionTemplate || t.Type == TokenTemplateHead {
		g := j.NewGoal()

		pe.TemplateLiteral = new(TemplateLiteral)
		if err := pe.TemplateLiteral.parse(&g, yield, await); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t == (parser.Token{Type: TokenPunctuator, Data: "("}) {
		g := j.NewGoal()

		pe.ParenthesizedExpression = new(ParenthesizedExpression)
		if err := pe.ParenthesizedExpression.parse(&g, yield, await); err != nil {
			return j.Error("PrimaryExpression", err)
		}

		j.Score(g)
	} else if t.Type == TokenJSXElementStart {
		g := j.NewGoal()

		g.Skip()

		if g.AcceptRunWhitespace() == TokenJSXElementEnd {
			g = j.NewGoal()
			pe.JSXFragment = new(JSXFragment)

			if err := pe.JSXFragment.parse(&g); err != nil {
				return j.Error("PrimaryExpression", err)
			}

			j.Score(g)
		} else {
			g = j.NewGoal()
			pe.JSXElement = new(JSXElement)

			if err := pe.JSXElement.parse(&g); err != nil {
				return j.Error("PrimaryExpression", err)
			}

			j.Score(g)
		}
	} else {
		g := j.NewGoal()

		if pe.IdentifierReference = g.parseIdentifier(yield, await); pe.IdentifierReference == nil {
			return j.Error("PrimaryExpression", ErrNoIdentifier)
		}

		j.Score(g)
	}

	pe.Tokens = j.ToTokens()

	return nil
}

// IsSimple returns whether or not the PrimaryExpression is classed as 'simple'
func (pe *PrimaryExpression) IsSimple() bool {
	return pe.IdentifierReference != nil && pe.IdentifierReference.Data != "eval" && pe.IdentifierReference.Data != "arguments"
}

// ParenthesizedExpression as defined in ECMA-262
// https://262.ecma-international.org/11.0/#prod-ParenthesizedExpression
type ParenthesizedExpression struct {
	Expressions []AssignmentExpression
	Comments    [2]Comments
	Tokens      Tokens
}

func (pe *ParenthesizedExpression) parse(j *jsParser, yield, await bool) error {
	if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "("}) {
		return j.Error("ParenthesizedExpression", ErrMissingOpeningParenthesis)
	}

	pe.Comments[0] = j.AcceptRunWhitespaceNoNewlineComments()

	j.AcceptRunWhitespaceNoComment()

	g := j.NewGoal()

	g.AcceptRunWhitespace()

	if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ")"}) {
		for {
			g := j.NewGoal()
			e := len(pe.Expressions)

			pe.Expressions = append(pe.Expressions, AssignmentExpression{})
			if err := pe.Expressions[e].parse(&g, true, yield, await); err != nil {
				return j.Error("ParenthesizedExpression", err)
			}

			j.Score(g)

			g = j.NewGoal()

			g.AcceptRunWhitespace()

			if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ")"}) {
				break
			} else if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ","}) {
				return g.Error("ParenthesizedExpression", ErrMissingComma)
			}

			j.Score(g)

			j.AcceptRunWhitespaceNoComment()
		}
	}

	pe.Comments[1] = j.AcceptRunWhitespaceComments()

	j.AcceptRunWhitespace()
	j.Skip()

	pe.Tokens = j.ToTokens()

	return nil
}

// Arguments as defined in TC39
// https://tc39.es/ecma262/#prod-Arguments
type Arguments struct {
	ArgumentList []Argument
	Comments     [2]Comments
	Tokens       Tokens
}

func (a *Arguments) parse(j *jsParser, yield, await bool) error {
	if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "("}) {
		return j.Error("Arguments", ErrMissingOpeningParenthesis)
	}

	a.Comments[0] = j.AcceptRunWhitespaceNoNewlineComments()

	for {
		j.AcceptRunWhitespaceNoComment()

		g := j.NewGoal()

		g.AcceptRunWhitespace()

		if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ")"}) {
			break
		}

		ae := len(a.ArgumentList)
		g = j.NewGoal()

		a.ArgumentList = append(a.ArgumentList, Argument{})
		if err := a.ArgumentList[ae].parse(&g, yield, await); err != nil {
			return j.Error("Arguments", err)
		}

		j.Score(g)

		g = j.NewGoal()

		g.AcceptRunWhitespace()

		if g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ")"}) {
			break
		} else if !g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ","}) {
			return g.Error("Arguments", ErrMissingComma)
		}

		j.Score(g)
	}

	a.Comments[1] = j.AcceptRunWhitespaceComments()

	j.AcceptRunWhitespace()
	j.Skip()

	a.Tokens = j.ToTokens()

	return nil
}

func (a *Arguments) hasSingleLineComment() bool {
	return a != nil && (hasSingleLineComment(a.Comments[:]) || hasSingleLineComment(a.ArgumentList))
}

// Argument is an item in an ArgumentList and contains the spread information
// and the AssignementExpression
type Argument struct {
	Spread               bool
	AssignmentExpression AssignmentExpression
	Comments             Comments
	Tokens               Tokens
}

func (a *Argument) parse(j *jsParser, yield, await bool) error {
	g := j.NewGoal()

	g.AcceptRunWhitespace()

	if a.Spread = g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "..."}); a.Spread {
		a.Comments = j.AcceptRunWhitespaceComments()

		j.AcceptRunWhitespace()
		j.Skip()
	}

	j.AcceptRunWhitespaceNoComment()

	g = j.NewGoal()

	if err := a.AssignmentExpression.parse(&g, true, yield, await); err != nil {
		return j.Error("Argument", err)
	}

	j.Score(g)

	a.Tokens = j.ToTokens()

	return nil
}

func (a Argument) hasSingleLineComment() bool {
	return a.Comments.hasSingleLineComment() || a.AssignmentExpression.hasSingleLineComment()
}

// CallExpression as defined in ECMA-262
// https://tc39.es/ecma262/#prod-CallExpression
//
// It is only valid for one of MemberExpression, ImportCall, or CallExpression
// to be non-nil or SuperCall to be true.
//
// If MemberExpression is non-nil, or SuperCall is true, Arguments must be
// non-nil.
//
// If CallExpression is non-nil, only one of Arguments, Expression,
// IdentifierName, TemplateLiteral, or PrivateIdentifier must be non-nil.
type CallExpression struct {
	MemberExpression  *MemberExpression
	SuperCall         bool
	ImportCall        *AssignmentExpression
	CallExpression    *CallExpression
	Arguments         *Arguments
	Expression        *Expression
	IdentifierName    *Token
	TemplateLiteral   *TemplateLiteral
	PrivateIdentifier *Token
	Comments          [5]Comments
	Tokens            Tokens
}

func (ce *CallExpression) parse(j *jsParser, me *MemberExpression, yield, await bool) error {
	skip := false

	if me == nil {
		ce.Comments[0] = j.AcceptRunWhitespaceComments()

		j.AcceptRunWhitespace()

		if j.AcceptToken(parser.Token{Type: TokenKeyword, Data: "super"}) {
			ce.SuperCall = true
		} else if j.AcceptToken(parser.Token{Type: TokenKeyword, Data: "import"}) {
			ce.Comments[1] = j.AcceptRunWhitespaceComments()

			j.AcceptRunWhitespace()

			if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "("}) {
				return j.Error("CallExpression", ErrMissingOpeningParenthesis)
			}

			ce.Comments[2] = j.AcceptRunWhitespaceNoNewlineComments()

			j.AcceptRunWhitespaceNoComment()

			g := j.NewGoal()

			ce.ImportCall = new(AssignmentExpression)
			if err := ce.ImportCall.parse(&g, true, yield, await); err != nil {
				return j.Error("CallExpression", err)
			}

			j.Score(g)

			ce.Comments[3] = j.AcceptRunWhitespaceComments()

			j.AcceptRunWhitespace()

			if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ")"}) {
				return j.Error("CallExpression", ErrMissingClosingParenthesis)
			}

			ce.Comments[4] = j.AcceptRunWhitespaceCommentsInList()

			skip = true
		} else {
			return j.Error("CallExpression", ErrInvalidCallExpression)
		}
	} else {
		ce.MemberExpression = me
	}

	if !skip {
		ce.Comments[1] = j.AcceptRunWhitespaceComments()

		j.AcceptRunWhitespace()

		g := j.NewGoal()

		if g.SkipTypeArguments() {
			ce.Comments[1] = append(ce.Comments[1], g.ToTypescriptComments()...)

			g.AcceptRunWhitespace()
		}

		h := g.NewGoal()

		ce.Arguments = new(Arguments)
		if err := ce.Arguments.parse(&h, yield, await); err != nil {
			return j.Error("CallExpression", err)
		}

		ce.Comments[4] = h.AcceptRunWhitespaceCommentsInList()

		i := h.NewGoal()

		i.AcceptRunWhitespaceNoNewLine()

		k := i.NewGoal()

		if k.SkipForce() {
			ce.Comments[4] = append(ce.Comments[4], k.ToTypescriptComments()...)
			ce.Comments[4] = append(ce.Comments[4], k.AcceptRunWhitespaceCommentsInList()...)

			i.Score(k)
			h.Score(i)
		}

		g.Score(h)
		j.Score(g)
	}

	for {
		ce.Tokens = j.ToTokens()
		g := j.NewGoal()

		g.AcceptRunWhitespace()

		h := g.NewGoal()

		var (
			tl         *TemplateLiteral
			a          *Arguments
			i, p       *Token
			e          *Expression
			f, b, c, d Comments
		)

		switch tk := h.Peek(); tk.Type {
		case TokenNoSubstitutionTemplate, TokenTemplateHead:
			tl = new(TemplateLiteral)
			if err := tl.parse(&h, yield, await); err != nil {
				return g.Error("CallExpression", err)
			}

			d = h.AcceptRunWhitespaceCommentsInList()
		case TokenPunctuator:
			switch tk.Data {
			case "<":
				i := h.NewGoal()

				if i.SkipTypeArguments() {
					f = append(i.ToTypescriptComments(), i.AcceptRunWhitespaceComments()...)

					i.AcceptRunWhitespace()
				}

				if i.Peek() != (parser.Token{Type: TokenPunctuator, Data: "("}) {
					return nil
				}

				h.Score(i)
				g.Score(h)

				h = g.NewGoal()

				fallthrough
			case "(":
				a = new(Arguments)
				if err := a.parse(&h, yield, await); err != nil {
					return g.Error("CallExpression", err)
				}
			case ".":
				h.Skip()

				b = h.AcceptRunWhitespaceComments()
				h.AcceptRunWhitespace()

				if !h.Accept(TokenIdentifier, TokenKeyword, TokenPrivateIdentifier) {
					return h.Error("CallExpression", ErrNoIdentifier)
				}

				if i = h.GetLastToken(); i.Type == TokenPrivateIdentifier {
					p = i
					i = nil
				}
			case "[":
				h.Skip()

				b = h.AcceptRunWhitespaceNoNewlineComments()

				h.AcceptRunWhitespaceNoComment()

				i := h.NewGoal()

				e = new(Expression)
				if err := e.parse(&i, true, yield, await); err != nil {
					return g.Error("CallExpression", err)
				}

				h.Score(i)

				c = h.AcceptRunWhitespaceComments()

				h.AcceptRunWhitespace()

				if !h.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "]"}) {
					return h.Error("CallExpression", ErrMissingClosingBracket)
				}
			default:
				return nil
			}

			d = h.AcceptRunWhitespaceCommentsInList()
			i := h.NewGoal()

			i.AcceptRunWhitespaceNoNewLine()

			k := i.NewGoal()

			if k.SkipForce() {
				d = append(d, k.ToTypescriptComments()...)
				d = append(d, k.AcceptRunWhitespaceCommentsInList()...)

				i.Score(k)
				h.Score(i)
			}
		default:
			return nil
		}

		g.Score(h)

		nce := new(CallExpression)
		*nce = *ce
		*ce = CallExpression{
			CallExpression:    nce,
			Expression:        e,
			Arguments:         a,
			IdentifierName:    i,
			TemplateLiteral:   tl,
			PrivateIdentifier: p,
			Comments:          [5]Comments{nil, f, b, c, d},
		}

		j.Score(g)
	}
}

// IsSimple returns whether or not the CallExpression is classed as 'simple'
func (ce *CallExpression) IsSimple() bool {
	return ce.Expression != nil || ce.IdentifierName != nil || ce.PrivateIdentifier != nil
}

func (ce *CallExpression) hasFirstComment() bool {
	if ce.MemberExpression != nil {
		return ce.MemberExpression.hasFirstComment()
	}

	if ce.CallExpression != nil {
		return ce.CallExpression.hasFirstComment()
	}

	return false
}

func (ce *CallExpression) hasSingleLineComment() bool {
	return ce != nil && (hasSingleLineComment(ce.Comments[:]) || ce.MemberExpression.hasSingleLineComment() || ce.CallExpression.hasSingleLineComment())
}