ast_test.go

package javascript

import (
	"errors"
	"reflect"
	"testing"

	"vimagination.zapto.org/parser"
)

type sourceFn struct {
	Source string
	Fn     func(*test, Tokens)
}

type test struct {
	Tokens                                 jsParser
	Yield, Await, In, Def, Ret, Typescript bool
	Output                                 Type
	Err                                    error
}

func makeTokeniser(tk parser.Tokeniser) *parser.Tokeniser {
	return &tk
}

func doTests(t *testing.T, tests []sourceFn, fn func(*test) (Type, error), isJSX ...bool) {
	t.Helper()

	var err error

	for n, tt := range tests {
		var ts test

		var tk Tokeniser = makeTokeniser(parser.NewStringTokeniser(tt.Source))

		if len(isJSX) > 0 {
			tk = AsJSX(tk)
		}

		if ts.Tokens, err = newJSParser(tk); err != nil {
			t.Errorf("test %d: unexpected error: %s", n+1, err)

			continue
		}

		tt.Fn(&ts, Tokens(ts.Tokens[:cap(ts.Tokens)]))

		if output, err := fn(&ts); !reflect.DeepEqual(err, ts.Err) {
			t.Errorf("test %d: expecting error: %v, got %v", n+1, ts.Err, err)
		} else if ts.Output != nil && !reflect.DeepEqual(output, ts.Output) {
			t.Errorf("test %d: expecting \n%+v\n...got...\n%+v", n+1, ts.Output, output)
		}
	}
}

func assignmentError(tk Token) Error {
	return assignmentCustomError(tk, ErrNoIdentifier)
}

func assignmentCustomError(tk Token, err error) Error {
	return Error{
		Err: Error{
			Err: Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err: Error{
									Err: Error{
										Err: Error{
											Err: Error{
												Err: Error{
													Err: Error{
														Err: Error{
															Err: Error{
																Err: Error{
																	Err: Error{
																		Err: Error{
																			Err: Error{
																				Err:     err,
																				Parsing: "PrimaryExpression",
																				Token:   tk,
																			},
																			Parsing: "MemberExpression",
																			Token:   tk,
																		},
																		Parsing: "NewExpression",
																		Token:   tk,
																	},
																	Parsing: "LeftHandSideExpression",
																	Token:   tk,
																},
																Parsing: "UpdateExpression",
																Token:   tk,
															},
															Parsing: "UnaryExpression",
															Token:   tk,
														},
														Parsing: "ExponentiationExpression",
														Token:   tk,
													},
													Parsing: "MultiplicativeExpression",
													Token:   tk,
												},
												Parsing: "AdditiveExpression",
												Token:   tk,
											},
											Parsing: "ShiftExpression",
											Token:   tk,
										},
										Parsing: "RelationalExpression",
										Token:   tk,
									},
									Parsing: "EqualityExpression",
									Token:   tk,
								},
								Parsing: "BitwiseANDExpression",
								Token:   tk,
							},
							Parsing: "BitwiseXORExpression",
							Token:   tk,
						},
						Parsing: "BitwiseORExpression",
						Token:   tk,
					},
					Parsing: "LogicalANDExpression",
					Token:   tk,
				},
				Parsing: "LogicalORExpression",
				Token:   tk,
			},
			Parsing: "ConditionalExpression",
			Token:   tk,
		},
		Parsing: "AssignmentExpression",
		Token:   tk,
	}
}

func TestIdentifier(t *testing.T) {
	doTests(t, []sourceFn{
		{`hello_world`, func(t *test, tk Tokens) {
			t.Output = &tk[0]
		}},
		{`yield`, func(t *test, tk Tokens) {
			t.Output = &tk[0]
		}},
		{`yield`, func(t *test, tk Tokens) {
			t.Await = true
			t.Output = &tk[0]
		}},
		{`yield`, func(t *test, tk Tokens) {
			t.Yield = true
			t.Output = nil
		}},
		{`await`, func(t *test, tk Tokens) {
			t.Output = &tk[0]
		}},
		{`await`, func(t *test, tk Tokens) {
			t.Yield = true
			t.Output = &tk[0]
		}},
		{`await`, func(t *test, tk Tokens) {
			t.Await = true
			t.Output = nil
		}},
		{`for`, func(t *test, tk Tokens) {
			t.Output = nil
		}},
		{`"for"`, func(t *test, tk Tokens) {
			t.Output = nil
		}},
		{`1`, func(t *test, tk Tokens) {
			t.Output = nil
		}},
		{`+`, func(t *test, tk Tokens) {
			t.Output = nil
		}},
	}, func(t *test) (Type, error) {
		return t.Tokens.parseIdentifier(t.Yield, t.Await), nil
	})
}

func TestScript(t *testing.T) {
	doTests(t, []sourceFn{
		{`
"use strict";

document.body.innerHTML  =
	"Hello, World";

function	runMe	(v) 
{
	let x = v * 2;
	alert(x);
}

for(
	var a = 1;
	a < 10;
	a ++
) {
	runMe ( a );
}
`, func(t *test, tk Tokens) { // 1
			useStrict := makeConditionLiteral(tk, 1)
			helloWorld := makeConditionLiteral(tk, 13)
			v := makeConditionLiteral(tk, 34)
			two := makeConditionLiteral(tk, 38)
			multiply := wrapConditional(MultiplicativeExpression{
				MultiplicativeExpression: &v.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
				MultiplicativeOperator:   MultiplicativeMultiply,
				ExponentiationExpression: two.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
				Tokens:                   tk[34:39],
			})
			x := makeConditionLiteral(tk, 44)
			alert := wrapConditional(UpdateExpression{
				LeftHandSideExpression: &LeftHandSideExpression{
					CallExpression: &CallExpression{
						MemberExpression: &MemberExpression{
							PrimaryExpression: &PrimaryExpression{
								IdentifierReference: &tk[42],
								Tokens:              tk[42:43],
							},
							Tokens: tk[42:43],
						},
						Arguments: &Arguments{
							ArgumentList: []Argument{
								{
									AssignmentExpression: AssignmentExpression{
										ConditionalExpression: &x,
										Tokens:                tk[44:45],
									},
									Tokens: tk[44:45],
								},
							},
							Tokens: tk[43:46],
						},
						Tokens: tk[42:46],
					},
					Tokens: tk[42:46],
				},
				Tokens: tk[42:46],
			})
			one := makeConditionLiteral(tk, 60)
			a := makeConditionLiteral(tk, 64)
			ten := makeConditionLiteral(tk, 68)
			aLessThanTen := wrapConditional(RelationalExpression{
				RelationalExpression: &a.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
				RelationshipOperator: RelationshipLessThan,
				ShiftExpression:      ten.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
				Tokens:               tk[64:69],
			})
			aPlusPlus := wrapConditional(UpdateExpression{
				LeftHandSideExpression: &LeftHandSideExpression{
					NewExpression: &NewExpression{
						MemberExpression: MemberExpression{
							PrimaryExpression: &PrimaryExpression{
								IdentifierReference: &tk[72],
								Tokens:              tk[72:73],
							},
							Tokens: tk[72:73],
						},
						Tokens: tk[72:73],
					},
					Tokens: tk[72:73],
				},
				UpdateOperator: UpdatePostIncrement,
				Tokens:         tk[72:75],
			})
			argA := makeConditionLiteral(tk, 85)
			runMe := wrapConditional(UpdateExpression{
				LeftHandSideExpression: &LeftHandSideExpression{
					CallExpression: &CallExpression{
						MemberExpression: &MemberExpression{
							PrimaryExpression: &PrimaryExpression{
								IdentifierReference: &tk[81],
								Tokens:              tk[81:82],
							},
							Tokens: tk[81:82],
						},
						Arguments: &Arguments{
							ArgumentList: []Argument{
								{
									AssignmentExpression: AssignmentExpression{
										ConditionalExpression: &argA,
										Tokens:                tk[85:86],
									},
									Tokens: tk[85:86],
								},
							},
							Tokens: tk[83:88],
						},
						Tokens: tk[81:88],
					},
					Tokens: tk[81:88],
				},
				Tokens: tk[81:88],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										ConditionalExpression: &useStrict,
										Tokens:                tk[1:2],
									},
								},
								Tokens: tk[1:2],
							},
							Tokens: tk[1:3],
						},
						Tokens: tk[1:3],
					},
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										LeftHandSideExpression: &LeftHandSideExpression{
											NewExpression: &NewExpression{
												MemberExpression: MemberExpression{
													MemberExpression: &MemberExpression{
														MemberExpression: &MemberExpression{
															PrimaryExpression: &PrimaryExpression{
																IdentifierReference: &tk[4],
																Tokens:              tk[4:5],
															},
															Tokens: tk[4:5],
														},
														IdentifierName: &tk[6],
														Tokens:         tk[4:7],
													},
													IdentifierName: &tk[8],
													Tokens:         tk[4:9],
												},
												Tokens: tk[4:9],
											},
											Tokens: tk[4:9],
										},
										AssignmentOperator: AssignmentAssign,
										AssignmentExpression: &AssignmentExpression{
											ConditionalExpression: &helloWorld,
											Tokens:                tk[13:14],
										},
										Tokens: tk[4:14],
									},
								},
								Tokens: tk[4:14],
							},
							Tokens: tk[4:15],
						},
						Tokens: tk[4:15],
					},
					{
						Declaration: &Declaration{
							FunctionDeclaration: &FunctionDeclaration{
								BindingIdentifier: &tk[18],
								FormalParameters: FormalParameters{
									FormalParameterList: []BindingElement{
										{
											SingleNameBinding: &tk[21],
											Tokens:            tk[21:22],
										},
									},
									Tokens: tk[20:23],
								},
								FunctionBody: Block{
									StatementList: []StatementListItem{
										{
											Declaration: &Declaration{
												LexicalDeclaration: &LexicalDeclaration{
													LetOrConst: Let,
													BindingList: []LexicalBinding{
														{
															BindingIdentifier: &tk[30],
															Initializer: &AssignmentExpression{
																ConditionalExpression: &multiply,
																Tokens:                tk[34:39],
															},
															Tokens: tk[30:39],
														},
													},
													Tokens: tk[28:40],
												},
												Tokens: tk[28:40],
											},
											Tokens: tk[28:40],
										},
										{
											Statement: &Statement{
												ExpressionStatement: &Expression{
													Expressions: []AssignmentExpression{
														{
															ConditionalExpression: &alert,
															Tokens:                tk[42:46],
														},
													},
													Tokens: tk[42:46],
												},
												Tokens: tk[42:47],
											},
											Tokens: tk[42:47],
										},
									},
									Tokens: tk[25:49],
								},
								Tokens: tk[16:49],
							},
							Tokens: tk[16:49],
						},
						Tokens: tk[16:49],
					},
					{
						Statement: &Statement{
							IterationStatementFor: &IterationStatementFor{
								Type: ForNormalVar,
								InitVar: []VariableDeclaration{
									{
										BindingIdentifier: &tk[56],
										Initializer: &AssignmentExpression{
											ConditionalExpression: &one,
											Tokens:                tk[60:61],
										},
										Tokens: tk[56:61],
									},
								},
								Conditional: &Expression{
									Expressions: []AssignmentExpression{
										{
											ConditionalExpression: &aLessThanTen,
											Tokens:                tk[64:69],
										},
									},
									Tokens: tk[64:69],
								},
								Afterthought: &Expression{
									Expressions: []AssignmentExpression{
										{
											ConditionalExpression: &aPlusPlus,
											Tokens:                tk[72:75],
										},
									},
									Tokens: tk[72:75],
								},
								Statement: Statement{
									BlockStatement: &Block{
										StatementList: []StatementListItem{
											{
												Statement: &Statement{
													ExpressionStatement: &Expression{
														Expressions: []AssignmentExpression{
															{
																ConditionalExpression: &runMe,
																Tokens:                tk[81:88],
															},
														},
														Tokens: tk[81:88],
													},
													Tokens: tk[81:89],
												},
												Tokens: tk[81:89],
											},
										},
										Tokens: tk[78:91],
									},
									Tokens: tk[78:91],
								},
								Tokens: tk[50:91],
							},
							Tokens: tk[50:91],
						},
						Tokens: tk[50:91],
					},
				},
				Tokens: tk[:91],
			}
		}},
		{`if (typeof a === "b" && typeof c.d == "e") {}`, func(t *test, tk Tokens) { // 2
			litA := makeConditionLiteral(tk, 5)
			litB := makeConditionLiteral(tk, 9)
			litE := makeConditionLiteral(tk, 21)
			typeOfA := wrapConditional(UnaryExpression{
				UnaryOperators:   []UnaryOperatorComments{{UnaryOperator: UnaryTypeOf}},
				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
				Tokens:           tk[3:6],
			})
			CD := wrapConditional(UpdateExpression{
				LeftHandSideExpression: &LeftHandSideExpression{
					NewExpression: &NewExpression{
						MemberExpression: MemberExpression{
							MemberExpression: &MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[15],
									Tokens:              tk[15:16],
								},
								Tokens: tk[15:16],
							},
							IdentifierName: &tk[17],
							Tokens:         tk[15:18],
						},
						Tokens: tk[15:18],
					},
					Tokens: tk[15:18],
				},
				Tokens: tk[15:18],
			})
			typeOfCD := wrapConditional(UnaryExpression{
				UnaryOperators:   []UnaryOperatorComments{{UnaryOperator: UnaryTypeOf}},
				UpdateExpression: CD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
				Tokens:           tk[13:18],
			})
			AEquals := wrapConditional(EqualityExpression{
				EqualityExpression:   &typeOfA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
				EqualityOperator:     EqualityStrictEqual,
				RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
				Tokens:               tk[3:10],
			})
			CDEquals := wrapConditional(EqualityExpression{
				EqualityExpression:   &typeOfCD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
				EqualityOperator:     EqualityEqual,
				RelationalExpression: litE.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
				Tokens:               tk[13:22],
			})
			And := wrapConditional(LogicalANDExpression{
				LogicalANDExpression: &AEquals.LogicalORExpression.LogicalANDExpression,
				BitwiseORExpression:  CDEquals.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
				Tokens:               tk[3:22],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							IfStatement: &IfStatement{
								Expression: Expression{
									Expressions: []AssignmentExpression{
										{
											ConditionalExpression: &And,
											Tokens:                tk[3:22],
										},
									},
									Tokens: tk[3:22],
								},
								Statement: Statement{
									BlockStatement: &Block{
										Tokens: tk[24:26],
									},
									Tokens: tk[24:26],
								},
								Tokens: tk[:26],
							},
							Tokens: tk[:26],
						},
						Tokens: tk[:26],
					},
				},
				Tokens: tk[:26],
			}
		}},
		{"{ 1 2 } 3", func(t *test, tk Tokens) { // 3
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err:     ErrMissingSemiColon,
								Parsing: "Statement",
								Token:   tk[3],
							},
							Parsing: "StatementListItem",
							Token:   tk[2],
						},
						Parsing: "Block",
						Token:   tk[2],
					},
					Parsing: "Statement",
					Token:   tk[0],
				},
				Parsing: "StatementListItem",
				Token:   tk[0],
			}
		}},
		{"{ 1\n2 } 3", func(t *test, tk Tokens) { // 4
			lit1 := makeConditionLiteral(tk, 2)
			lit2 := makeConditionLiteral(tk, 4)
			lit3 := makeConditionLiteral(tk, 8)
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							BlockStatement: &Block{
								StatementList: []StatementListItem{
									{
										Statement: &Statement{
											ExpressionStatement: &Expression{
												Expressions: []AssignmentExpression{
													{
														ConditionalExpression: &lit1,
														Tokens:                tk[2:3],
													},
												},
												Tokens: tk[2:3],
											},
											Tokens: tk[2:3],
										},
										Tokens: tk[2:3],
									},
									{
										Statement: &Statement{
											ExpressionStatement: &Expression{
												Expressions: []AssignmentExpression{
													{
														ConditionalExpression: &lit2,
														Tokens:                tk[4:5],
													},
												},
												Tokens: tk[4:5],
											},
											Tokens: tk[4:5],
										},
										Tokens: tk[4:5],
									},
								},
								Tokens: tk[:7],
							},
							Tokens: tk[:7],
						},
						Tokens: tk[:7],
					},
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										ConditionalExpression: &lit3,
										Tokens:                tk[8:9],
									},
								},
								Tokens: tk[8:9],
							},
							Tokens: tk[8:9],
						},
						Tokens: tk[8:9],
					},
				},
				Tokens: tk[:9],
			}
		}},
		{"function fn() {\nreturn\na + b\n}", func(t *test, tk Tokens) { // 5
			litA := makeConditionLiteral(tk, 10)
			litB := makeConditionLiteral(tk, 14)
			add := wrapConditional(AdditiveExpression{
				AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
				AdditiveOperator:         AdditiveAdd,
				MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
				Tokens:                   tk[10:15],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Declaration: &Declaration{
							FunctionDeclaration: &FunctionDeclaration{
								BindingIdentifier: &tk[2],
								FormalParameters: FormalParameters{
									Tokens: tk[3:5],
								},
								FunctionBody: Block{
									StatementList: []StatementListItem{
										{
											Statement: &Statement{
												Type:   StatementReturn,
												Tokens: tk[8:9],
											},
											Tokens: tk[8:9],
										},
										{
											Statement: &Statement{
												ExpressionStatement: &Expression{
													Expressions: []AssignmentExpression{
														{
															ConditionalExpression: &add,
															Tokens:                tk[10:15],
														},
													},
													Tokens: tk[10:15],
												},
												Tokens: tk[10:15],
											},
											Tokens: tk[10:15],
										},
									},
									Tokens: tk[6:17],
								},
								Tokens: tk[:17],
							},
							Tokens: tk[:17],
						},
						Tokens: tk[:17],
					},
				},
				Tokens: tk[:17],
			}
		}},
		{"a = b\n++c", func(t *test, tk Tokens) { // 6
			litA := makeConditionLiteral(tk, 0)
			litB := makeConditionLiteral(tk, 4)
			litC := makeConditionLiteral(tk, 7)
			pa := wrapConditional(UpdateExpression{
				UpdateOperator:  UpdatePreIncrement,
				UnaryExpression: &litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
				Tokens:          tk[6:8],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										LeftHandSideExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
										AssignmentOperator:     AssignmentAssign,
										AssignmentExpression: &AssignmentExpression{
											ConditionalExpression: &litB,
											Tokens:                tk[4:5],
										},
										Tokens: tk[:5],
									},
								},
								Tokens: tk[:5],
							},
							Tokens: tk[:5],
						},
						Tokens: tk[:5],
					},
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										ConditionalExpression: &pa,
										Tokens:                tk[6:8],
									},
								},
								Tokens: tk[6:8],
							},
							Tokens: tk[6:8],
						},
						Tokens: tk[6:8],
					},
				},
				Tokens: tk[:8],
			}
		}},
		{"if (a > b)\nelse d = e", func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err:     assignmentError(tk[10]),
								Parsing: "Expression",
								Token:   tk[10],
							},
							Parsing: "Statement",
							Token:   tk[10],
						},
						Parsing: "IfStatement",
						Token:   tk[10],
					},
					Parsing: "Statement",
					Token:   tk[0],
				},
				Parsing: "StatementListItem",
				Token:   tk[0],
			}
		}},
		{"if\n(a\n>\nb)\nc\nelse\nd\n=\ne", func(t *test, tk Tokens) { // 8
			litA := makeConditionLiteral(tk, 3)
			litB := makeConditionLiteral(tk, 7)
			litC := makeConditionLiteral(tk, 10)
			litD := makeConditionLiteral(tk, 14)
			litE := makeConditionLiteral(tk, 18)
			ab := wrapConditional(RelationalExpression{
				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
				RelationshipOperator: RelationshipGreaterThan,
				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
				Tokens:               tk[3:8],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							IfStatement: &IfStatement{
								Expression: Expression{
									Expressions: []AssignmentExpression{
										{
											ConditionalExpression: &ab,
											Tokens:                tk[3:8],
										},
									},
									Tokens: tk[3:8],
								},
								Statement: Statement{
									ExpressionStatement: &Expression{
										Expressions: []AssignmentExpression{
											{
												ConditionalExpression: &litC,
												Tokens:                tk[10:11],
											},
										},
										Tokens: tk[10:11],
									},
									Tokens: tk[10:11],
								},
								ElseStatement: &Statement{
									ExpressionStatement: &Expression{
										Expressions: []AssignmentExpression{
											{
												LeftHandSideExpression: litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
												AssignmentOperator:     AssignmentAssign,
												AssignmentExpression: &AssignmentExpression{
													ConditionalExpression: &litE,
													Tokens:                tk[18:19],
												},
												Tokens: tk[14:19],
											},
										},
										Tokens: tk[14:19],
									},
									Tokens: tk[14:19],
								},
								Tokens: tk[:19],
							},
							Tokens: tk[:19],
						},
						Tokens: tk[:19],
					},
				},
				Tokens: tk[:19],
			}
		}},
		{"a = b + c\n(d + e).print()", func(t *test, tk Tokens) { // 9
			litA := makeConditionLiteral(tk, 0)
			litB := makeConditionLiteral(tk, 4)
			litD := makeConditionLiteral(tk, 11)
			litE := makeConditionLiteral(tk, 15)
			de := wrapConditional(AdditiveExpression{
				AdditiveExpression:       &litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
				AdditiveOperator:         AdditiveAdd,
				MultiplicativeExpression: litE.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
				Tokens:                   tk[11:16],
			})
			bc := wrapConditional(AdditiveExpression{
				AdditiveExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
				AdditiveOperator:   AdditiveAdd,
				MultiplicativeExpression: wrapConditional(UpdateExpression{
					LeftHandSideExpression: &LeftHandSideExpression{
						CallExpression: &CallExpression{
							CallExpression: &CallExpression{
								CallExpression: &CallExpression{
									MemberExpression: &MemberExpression{
										PrimaryExpression: &PrimaryExpression{
											IdentifierReference: &tk[8],
											Tokens:              tk[8:9],
										},
										Tokens: tk[8:9],
									},
									Arguments: &Arguments{
										ArgumentList: []Argument{
											{
												AssignmentExpression: AssignmentExpression{
													ConditionalExpression: &de,
													Tokens:                tk[11:16],
												},
												Tokens: tk[11:16],
											},
										},
										Tokens: tk[10:17],
									},
									Tokens: tk[8:17],
								},
								IdentifierName: &tk[18],
								Tokens:         tk[8:19],
							},
							Arguments: &Arguments{
								Tokens: tk[19:21],
							},
							Tokens: tk[8:21],
						},
						Tokens: tk[8:21],
					},
					Tokens: tk[8:21],
				}).LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
				Tokens: tk[4:21],
			})
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										LeftHandSideExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
										AssignmentOperator:     AssignmentAssign,
										AssignmentExpression: &AssignmentExpression{
											ConditionalExpression: &bc,
											Tokens:                tk[4:21],
										},
										Tokens: tk[:21],
									},
								},
								Tokens: tk[:21],
							},
							Tokens: tk[:21],
						},
						Tokens: tk[:21],
					},
				},
				Tokens: tk[:21],
			}
		}},
		{"await a", func(t *test, tk Tokens) { // 10
			t.Err = Error{
				Err: Error{
					Err:     ErrMissingSemiColon,
					Parsing: "Statement",
					Token:   tk[1],
				},
				Parsing: "StatementListItem",
				Token:   tk[0],
			}
		}},
		{"// A\na\n// B", func(t *test, tk Tokens) { // 11
			t.Output = Script{
				StatementList: []StatementListItem{
					{
						Statement: &Statement{
							ExpressionStatement: &Expression{
								Expressions: []AssignmentExpression{
									{
										ConditionalExpression: WrapConditional(&PrimaryExpression{
											IdentifierReference: &tk[2],
											Tokens:              tk[2:3],
										}),
										Tokens: tk[2:3],
									},
								},
								Tokens: tk[2:3],
							},
							Tokens: tk[2:3],
						},
						Tokens: tk[2:3],
					},
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:5],
			}
		}},
	}, func(t *test) (Type, error) {
		var s Script

		err := s.parse(&t.Tokens)

		return s, err
	})
}

func TestDeclaration(t *testing.T) {
	doTests(t, []sourceFn{
		{`class`, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "ClassDeclaration",
					Token:   tk[1],
				},
				Parsing: "Declaration",
				Token:   tk[0],
			}
		}},
		{`class a{}`, func(t *test, tk Tokens) { // 2
			t.Output = Declaration{
				ClassDeclaration: &ClassDeclaration{
					BindingIdentifier: &tk[2],
					Tokens:            tk[:5],
				},
				Tokens: tk[:5],
			}
		}},
		{`const`, func(t *test, tk Tokens) { // 3
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "LexicalBinding",
						Token:   tk[1],
					},
					Parsing: "LexicalDeclaration",
					Token:   tk[1],
				},
				Parsing: "Declaration",
				Token:   tk[0],
			}
		}},
		{`const a = 1;`, func(t *test, tk Tokens) { // 4
			lit1 := makeConditionLiteral(tk, 6)
			t.Output = Declaration{
				LexicalDeclaration: &LexicalDeclaration{
					LetOrConst: Const,
					BindingList: []LexicalBinding{
						{
							BindingIdentifier: &tk[2],
							Initializer: &AssignmentExpression{
								ConditionalExpression: &lit1,
								Tokens:                tk[6:7],
							},
							Tokens: tk[2:7],
						},
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{`let`, func(t *test, tk Tokens) { // 5
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "LexicalBinding",
						Token:   tk[1],
					},
					Parsing: "LexicalDeclaration",
					Token:   tk[1],
				},
				Parsing: "Declaration",
				Token:   tk[0],
			}
		}},
		{`let a = 1;`, func(t *test, tk Tokens) { // 6
			lit1 := makeConditionLiteral(tk, 6)
			t.Output = Declaration{
				LexicalDeclaration: &LexicalDeclaration{
					LetOrConst: Let,
					BindingList: []LexicalBinding{
						{
							BindingIdentifier: &tk[2],
							Initializer: &AssignmentExpression{
								ConditionalExpression: &lit1,
								Tokens:                tk[6:7],
							},
							Tokens: tk[2:7],
						},
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{`function`, func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "FunctionDeclaration",
					Token:   tk[1],
				},
				Parsing: "Declaration",
				Token:   tk[0],
			}
		}},
		{`function a(){}`, func(t *test, tk Tokens) { // 8
			t.Output = Declaration{
				FunctionDeclaration: &FunctionDeclaration{
					BindingIdentifier: &tk[2],
					FormalParameters: FormalParameters{
						Tokens: tk[3:5],
					},
					FunctionBody: Block{
						Tokens: tk[5:7],
					},
					Tokens: tk[:7],
				},
				Tokens: tk[:7],
			}
		}},
		{`wrong`, func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err:     ErrInvalidDeclaration,
				Parsing: "Declaration",
				Token:   tk[0],
			}
		}},
	}, func(t *test) (Type, error) {
		var d Declaration

		err := d.parse(&t.Tokens, t.Yield, t.Await, false)

		return d, err
	})
}

func TestLexicalDeclaration(t *testing.T) {
	doTests(t, []sourceFn{
		{`wrong`, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrInvalidLexicalDeclaration,
				Parsing: "LexicalDeclaration",
				Token:   tk[0],
			}
		}},
		{`const`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "LexicalBinding",
					Token:   tk[1],
				},
				Parsing: "LexicalDeclaration",
				Token:   tk[1],
			}
		}},
		{"const\na", func(t *test, tk Tokens) { // 3
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:3],
			}
		}},
		{"const\na\n", func(t *test, tk Tokens) { // 4
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:3],
			}
		}},
		{"const\na;", func(t *test, tk Tokens) { // 5
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:4],
			}
		}},
		{"const\na,\nb;", func(t *test, tk Tokens) { // 6
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
					{
						BindingIdentifier: &tk[5],
						Tokens:            tk[5:6],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"const \n a;", func(t *test, tk Tokens) { // 7
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[4],
						Tokens:            tk[4:5],
					},
				},
				Tokens: tk[:6],
			}
		}},
		{"const \n a, \n b;", func(t *test, tk Tokens) { // 8
			t.Output = LexicalDeclaration{
				LetOrConst: Const,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[4],
						Tokens:            tk[4:5],
					},
					{
						BindingIdentifier: &tk[9],
						Tokens:            tk[9:10],
					},
				},
				Tokens: tk[:11],
			}
		}},
		{`let`, func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "LexicalBinding",
					Token:   tk[1],
				},
				Parsing: "LexicalDeclaration",
				Token:   tk[1],
			}
		}},
		{"let\na", func(t *test, tk Tokens) { // 10
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:3],
			}
		}},
		{"let\na\n", func(t *test, tk Tokens) { // 11
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:3],
			}
		}},
		{"let\na;", func(t *test, tk Tokens) { // 12
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:4],
			}
		}},
		{"let\na,\nb;", func(t *test, tk Tokens) { // 13
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[2],
						Tokens:            tk[2:3],
					},
					{
						BindingIdentifier: &tk[5],
						Tokens:            tk[5:6],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"let \n a;", func(t *test, tk Tokens) { // 14
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[4],
						Tokens:            tk[4:5],
					},
				},
				Tokens: tk[:6],
			}
		}},
		{"let \n a, \n b;", func(t *test, tk Tokens) { // 15
			t.Output = LexicalDeclaration{
				LetOrConst: Let,
				BindingList: []LexicalBinding{
					{
						BindingIdentifier: &tk[4],
						Tokens:            tk[4:5],
					},
					{
						BindingIdentifier: &tk[9],
						Tokens:            tk[9:10],
					},
				},
				Tokens: tk[:11],
			}
		}},
		{"let\na b;", func(t *test, tk Tokens) { // 16
			t.Err = Error{
				Err:     ErrInvalidLexicalDeclaration,
				Parsing: "LexicalDeclaration",
				Token:   tk[3],
			}
		}},
	}, func(t *test) (Type, error) {
		var ld LexicalDeclaration

		err := ld.parse(&t.Tokens, t.In, t.Yield, t.Await)

		return ld, err
	})
}

func TestLexicalBinding(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrNoIdentifier,
				Parsing: "LexicalBinding",
				Token:   tk[0],
			}
		}},
		{`a`, func(t *test, tk Tokens) { // 2
			t.Output = LexicalBinding{
				BindingIdentifier: &tk[0],
				Tokens:            tk[:1],
			}
		}},
		{"a\n=\n1", func(t *test, tk Tokens) { // 3
			lit1 := makeConditionLiteral(tk, 4)
			t.Output = LexicalBinding{
				BindingIdentifier: &tk[0],
				Initializer: &AssignmentExpression{
					ConditionalExpression: &lit1,
					Tokens:                tk[4:5],
				},
				Tokens: tk[:5],
			}
		}},
		{`[a]`, func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err:     ErrMissingInitializer,
				Parsing: "LexicalBinding",
				Token:   tk[3],
			}
		}},
		{"[a]\n=\n", func(t *test, tk Tokens) { // 5
			t.Err = Error{
				Err:     assignmentError(tk[6]),
				Parsing: "LexicalBinding",
				Token:   tk[6],
			}
		}},
		{"[]\n=\na", func(t *test, tk Tokens) { // 6
			litA := makeConditionLiteral(tk, 5)
			t.Output = LexicalBinding{
				ArrayBindingPattern: &ArrayBindingPattern{
					Tokens: tk[:2],
				},
				Initializer: &AssignmentExpression{
					ConditionalExpression: &litA,
					Tokens:                tk[5:6],
				},
				Tokens: tk[:6],
			}
		}},
		{`{a}`, func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err:     ErrMissingInitializer,
				Parsing: "LexicalBinding",
				Token:   tk[3],
			}
		}},
		{"{a}\n=\n", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err:     assignmentError(tk[6]),
				Parsing: "LexicalBinding",
				Token:   tk[6],
			}
		}},
		{"{}\n=\na", func(t *test, tk Tokens) { // 9
			litA := makeConditionLiteral(tk, 5)
			t.Output = LexicalBinding{
				ObjectBindingPattern: &ObjectBindingPattern{
					Tokens: tk[:2],
				},
				Initializer: &AssignmentExpression{
					ConditionalExpression: &litA,
					Tokens:                tk[5:6],
				},
				Tokens: tk[:6],
			}
		}},
		{`[!]`, func(t *test, tk Tokens) { // 10
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "ArrayBindingPattern",
					Token:   tk[1],
				},
				Parsing: "LexicalBinding",
				Token:   tk[0],
			}
		}},
		{`{!}`, func(t *test, tk Tokens) { // 11
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrInvalidPropertyName,
							Parsing: "PropertyName",
							Token:   tk[1],
						},
						Parsing: "BindingProperty",
						Token:   tk[1],
					},
					Parsing: "ObjectBindingPattern",
					Token:   tk[1],
				},
				Parsing: "LexicalBinding",
				Token:   tk[0],
			}
		}},
		{"// A\na // B\n", func(t *test, tk Tokens) { // 12
			t.Output = LexicalBinding{
				BindingIdentifier: &tk[2],
				Comments:          [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:            tk[:5],
			}
		}},
		{"// A\na // B\n= // C\nb // D\n", func(t *test, tk Tokens) { // 13
			t.Output = LexicalBinding{
				BindingIdentifier: &tk[2],
				Initializer: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[10],
							Tokens:              tk[10:11],
						},
						Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
						Tokens:   tk[8:13],
					}),
					Tokens: tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
		{"// A\n[]// B\n= // C\na // D", func(t *test, tk Tokens) { // 14
			t.Output = LexicalBinding{
				ArrayBindingPattern: &ArrayBindingPattern{
					Tokens: tk[2:4],
				},
				Initializer: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[10],
							Tokens:              tk[10:11],
						},
						Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
						Tokens:   tk[8:13],
					}),
					Tokens: tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
		{"// A\n{}// B\n= // C\na // D", func(t *test, tk Tokens) { // 15
			t.Output = LexicalBinding{
				ObjectBindingPattern: &ObjectBindingPattern{
					Tokens: tk[2:4],
				},
				Initializer: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[10],
							Tokens:              tk[10:11],
						},
						Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
						Tokens:   tk[8:13],
					}),
					Tokens: tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
	}, func(t *test) (Type, error) {
		var lb LexicalBinding

		err := lb.parse(&t.Tokens, t.In, t.Yield, t.Await)

		return lb, err
	})
}

func TestArrayBindingPattern(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrMissingOpeningBracket,
				Parsing: "ArrayBindingPattern",
				Token:   tk[0],
			}
		}},
		{`{}`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err:     ErrMissingOpeningBracket,
				Parsing: "ArrayBindingPattern",
				Token:   tk[0],
			}
		}},
		{"[\n]", func(t *test, tk Tokens) { // 3
			t.Output = ArrayBindingPattern{
				Tokens: tk[:3],
			}
		}},
		{"[\nnull\n]", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "BindingElement",
					Token:   tk[2],
				},
				Parsing: "ArrayBindingPattern",
				Token:   tk[2],
			}
		}},
		{"[\n,\n]", func(t *test, tk Tokens) { // 5
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						Tokens: tk[2:2],
					},
				},
				Tokens: tk[:5],
			}
		}},
		{"[\n,\n,\n]", func(t *test, tk Tokens) { // 6
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						Tokens: tk[2:2],
					},
					{
						Tokens: tk[4:4],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n...\na\n]", func(t *test, tk Tokens) { // 7
			t.Output = ArrayBindingPattern{
				BindingRestElement: &BindingElement{
					SingleNameBinding: &tk[4],
					Tokens:            tk[4:5],
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n...\nnull\n]", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "BindingElement",
					Token:   tk[4],
				},
				Parsing: "ArrayBindingPattern",
				Token:   tk[4],
			}
		}},
		{"[\n...\na\n,]", func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err:     ErrMissingClosingBracket,
				Parsing: "ArrayBindingPattern",
				Token:   tk[6],
			}
		}},
		{"[\na\n]", func(t *test, tk Tokens) { // 10
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						SingleNameBinding: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:5],
			}
		}},
		{"[\na\n,\n]", func(t *test, tk Tokens) { // 11
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						SingleNameBinding: &tk[2],
						Tokens:            tk[2:3],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\na\n,\n,\n]", func(t *test, tk Tokens) { // 12
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						SingleNameBinding: &tk[2],
						Tokens:            tk[2:3],
					},
					{
						Tokens: tk[5:5],
					},
				},
				Tokens: tk[:9],
			}
		}},
		{"[\n,\na\n]", func(t *test, tk Tokens) { // 13
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						Tokens: tk[2:2],
					},
					{
						SingleNameBinding: &tk[4],
						Tokens:            tk[4:5],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n,\nnull\n]", func(t *test, tk Tokens) { // 14
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "BindingElement",
					Token:   tk[4],
				},
				Parsing: "ArrayBindingPattern",
				Token:   tk[4],
			}
		}},
		{"[\na,\n,\n...\nb\n]", func(t *test, tk Tokens) { // 15
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						SingleNameBinding: &tk[2],
						Tokens:            tk[2:3],
					},
					{
						Tokens: tk[4:4],
					},
				},
				BindingRestElement: &BindingElement{
					SingleNameBinding: &tk[9],
					Tokens:            tk[9:10],
				},
				Tokens: tk[:12],
			}
		}},
		{"[\na\nb\n]", func(t *test, tk Tokens) { // 16
			t.Err = Error{
				Err:     ErrMissingComma,
				Parsing: "ArrayBindingPattern",
				Token:   tk[4],
			}
		}},
		{"[ // A\n\n// B\n]", func(t *test, tk Tokens) { // 17
			t.Output = ArrayBindingPattern{
				Comments: [3]Comments{{&tk[2]}, nil, {&tk[4]}},
				Tokens:   tk[:7],
			}
		}},
		{"[ // A\n\n// B\n...// C\na // D\n\n// E\n]", func(t *test, tk Tokens) { // 18
			t.Output = ArrayBindingPattern{
				BindingRestElement: &BindingElement{
					SingleNameBinding: &tk[9],
					Comments:          [2]Comments{{&tk[7]}, {&tk[11]}},
					Tokens:            tk[7:12],
				},
				Comments: [3]Comments{{&tk[2]}, {&tk[4]}, {&tk[13]}},
				Tokens:   tk[:16],
			}
		}},
		{"[ // A\n\n// B\na // C\n, // D\n\n// E\n, // F\n... // G\nb // H\n\n// I\n]", func(t *test, tk Tokens) { // 19
			t.Output = ArrayBindingPattern{
				BindingElementList: []BindingElement{
					{
						SingleNameBinding: &tk[6],
						Comments:          [2]Comments{{&tk[4]}, {&tk[8]}},
						Tokens:            tk[4:9],
					},
					{
						Comments: [2]Comments{{&tk[12], &tk[14]}},
						Tokens:   tk[12:15],
					},
				},
				BindingRestElement: &BindingElement{
					SingleNameBinding: &tk[24],
					Comments:          [2]Comments{{&tk[22]}, {&tk[26]}},
					Tokens:            tk[22:27],
				},
				Comments: [3]Comments{{&tk[2]}, {&tk[18]}, {&tk[28]}},
				Tokens:   tk[:31],
			}
		}},
	}, func(t *test) (Type, error) {
		var ab ArrayBindingPattern

		err := ab.parse(&t.Tokens, t.Yield, t.Await)

		return ab, err
	})
}

func TestObjectBindingPattern(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrMissingOpeningBrace,
				Parsing: "ObjectBindingPattern",
				Token:   tk[0],
			}
		}},
		{`[]`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err:     ErrMissingOpeningBrace,
				Parsing: "ObjectBindingPattern",
				Token:   tk[0],
			}
		}},
		{"{\n}", func(t *test, tk Tokens) { // 3
			t.Output = ObjectBindingPattern{
				Tokens: tk[:3],
			}
		}},
		{"{\n...\nnull\n}", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err:     ErrNoIdentifier,
				Parsing: "ObjectBindingPattern",
				Token:   tk[4],
			}
		}},
		{"{\n...\na\n}", func(t *test, tk Tokens) { // 5
			t.Output = ObjectBindingPattern{
				BindingRestProperty: &tk[4],
				Tokens:              tk[:7],
			}
		}},
		{"{\n...\na\nb\n}", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err:     ErrMissingClosingBrace,
				Parsing: "ObjectBindingPattern",
				Token:   tk[6],
			}
		}},
		{"{\nnull\n}", func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrInvalidPropertyName,
						Parsing: "PropertyName",
						Token:   tk[2],
					},
					Parsing: "BindingProperty",
					Token:   tk[2],
				},
				Parsing: "ObjectBindingPattern",
				Token:   tk[2],
			}
		}},
		{"{\na\n}", func(t *test, tk Tokens) { // 8
			t.Output = ObjectBindingPattern{
				BindingPropertyList: []BindingProperty{
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[2],
							Tokens:            tk[2:3],
						},
						Tokens: tk[2:3],
					},
				},
				Tokens: tk[:5],
			}
		}},
		{"{\na\nb\n}", func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err:     ErrMissingComma,
				Parsing: "ObjectBindingPattern",
				Token:   tk[4],
			}
		}},
		{"{\na,\nb\n}", func(t *test, tk Tokens) { // 10
			t.Output = ObjectBindingPattern{
				BindingPropertyList: []BindingProperty{
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[2],
							Tokens:            tk[2:3],
						},
						Tokens: tk[2:3],
					},
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[5],
							Tokens:              tk[5:6],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[5],
							Tokens:            tk[5:6],
						},
						Tokens: tk[5:6],
					},
				},
				Tokens: tk[:8],
			}
		}},
		{"{\na,\n...\nb\n}", func(t *test, tk Tokens) { // 11
			t.Output = ObjectBindingPattern{
				BindingPropertyList: []BindingProperty{
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[2],
							Tokens:            tk[2:3],
						},
						Tokens: tk[2:3],
					},
				},
				BindingRestProperty: &tk[7],
				Tokens:              tk[:10],
			}
		}},
		{"{ // A\n\n// B\na // C\n\n// D\n}", func(t *test, tk Tokens) { // 12
			t.Output = ObjectBindingPattern{
				BindingPropertyList: []BindingProperty{
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[6],
							Tokens:              tk[6:7],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[6],
							Comments:          [2]Comments{{&tk[4]}, {&tk[8]}},
							Tokens:            tk[4:9],
						},
						Tokens: tk[4:9],
					},
				},
				Comments: [5]Comments{{&tk[2]}, nil, nil, nil, {&tk[10]}},
				Tokens:   tk[:13],
			}
		}},
		{"{ // A\n\n// B\n...// C\na // D\n// E\n\n//F\n}", func(t *test, tk Tokens) { // 13
			t.Output = ObjectBindingPattern{
				BindingRestProperty: &tk[9],
				Comments:            [5]Comments{{&tk[2]}, {&tk[4]}, {&tk[7]}, {&tk[11], &tk[13]}, {&tk[15]}},
				Tokens:              tk[:18],
			}
		}},
		{"{ // A\n\n// B\na // C\n, // D\n...// E\nb // F\n\n// G\n}", func(t *test, tk Tokens) { // 14
			t.Output = ObjectBindingPattern{
				BindingPropertyList: []BindingProperty{
					{
						PropertyName: PropertyName{
							LiteralPropertyName: &tk[6],
							Tokens:              tk[6:7],
						},
						BindingElement: BindingElement{
							SingleNameBinding: &tk[6],
							Comments:          [2]Comments{{&tk[4]}, {&tk[8]}},
							Tokens:            tk[4:9],
						},
						Tokens: tk[4:9],
					},
				},
				BindingRestProperty: &tk[17],
				Comments:            [5]Comments{{&tk[2]}, {&tk[12]}, {&tk[15]}, {&tk[19]}, {&tk[21]}},
				Tokens:              tk[:24],
			}
		}},
	}, func(t *test) (Type, error) {
		var ob ObjectBindingPattern

		err := ob.parse(&t.Tokens, t.Yield, t.Await)

		return ob, err
	})
}

func TestBindingProperty(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err: Error{
					Err:     ErrInvalidPropertyName,
					Parsing: "PropertyName",
					Token:   tk[0],
				},
				Parsing: "BindingProperty",
				Token:   tk[0],
			}
		}},
		{`null`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err: Error{
					Err:     ErrInvalidPropertyName,
					Parsing: "PropertyName",
					Token:   tk[0],
				},
				Parsing: "BindingProperty",
				Token:   tk[0],
			}
		}},
		{`a`, func(t *test, tk Tokens) { // 3
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[0],
					Tokens:            tk[:1],
				},
				Tokens: tk[:1],
			}
		}},
		{"a\n=\n", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err: Error{
					Err:     assignmentError(tk[4]),
					Parsing: "BindingElement",
					Token:   tk[4],
				},
				Parsing: "BindingProperty",
				Token:   tk[0],
			}
		}},
		{"a\n=\n1", func(t *test, tk Tokens) { // 5
			lit1 := makeConditionLiteral(tk, 4)
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[0],
					Initializer: &AssignmentExpression{
						ConditionalExpression: &lit1,
						Tokens:                tk[4:5],
					},
					Tokens: tk[:5],
				},
				Tokens: tk[:5],
			}
		}},
		{"a\n:\n", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "BindingElement",
					Token:   tk[4],
				},
				Parsing: "BindingProperty",
				Token:   tk[4],
			}
		}},
		{"'a'", func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err:     ErrMissingColon,
				Parsing: "BindingProperty",
				Token:   tk[1],
			}
		}},
		{"a\n:\n''", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err: Error{
					Err:     ErrNoIdentifier,
					Parsing: "BindingElement",
					Token:   tk[4],
				},
				Parsing: "BindingProperty",
				Token:   tk[4],
			}
		}},
		{"a\n:\nb", func(t *test, tk Tokens) { // 9
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[4],
					Tokens:            tk[4:5],
				},
				Tokens: tk[:5],
			}
		}},

		{"// A\na // B\n", func(t *test, tk Tokens) { // 10
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[2],
					Comments:          [2]Comments{{&tk[0]}, {&tk[4]}},
					Tokens:            tk[:5],
				},
				Tokens: tk[:5],
			}
		}},
		{"// A\na // B\n= // C\nb // D", func(t *test, tk Tokens) { // 11
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[2],
					Initializer: &AssignmentExpression{
						ConditionalExpression: WrapConditional(&MemberExpression{
							PrimaryExpression: &PrimaryExpression{
								IdentifierReference: &tk[10],
								Tokens:              tk[10:11],
							},
							Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
							Tokens:   tk[8:13],
						}),
						Tokens: tk[8:13],
					},
					Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
					Tokens:   tk[:13],
				},
				Tokens: tk[:13],
			}
		}},
		{"// A\na // B\n: // C\nb // D\n", func(t *test, tk Tokens) { // 12
			t.Output = BindingProperty{
				PropertyName: PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				BindingElement: BindingElement{
					SingleNameBinding: &tk[10],
					Comments:          [2]Comments{{&tk[8]}, {&tk[12]}},
					Tokens:            tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
	}, func(t *test) (Type, error) {
		var bp BindingProperty

		err := bp.parse(&t.Tokens, t.Yield, t.Await)

		return bp, err
	})
}

func TestArrayLiteral(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrMissingOpeningBracket,
				Parsing: "ArrayLiteral",
				Token:   tk[0],
			}
		}},
		{`{}`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err:     ErrMissingOpeningBracket,
				Parsing: "ArrayLiteral",
				Token:   tk[0],
			}
		}},
		{"[\n]", func(t *test, tk Tokens) { // 3
			t.Output = ArrayLiteral{
				Tokens: tk[:3],
			}
		}},
		{"[\n,\n]", func(t *test, tk Tokens) { // 4
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{},
				},
				Tokens: tk[:5],
			}
		}},
		{"[\n,\n,\n]", func(t *test, tk Tokens) { // 5
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{},
					{},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n...\n]", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err: Error{
					Err:     assignmentError(tk[4]),
					Parsing: "ArrayElement",
					Token:   tk[2],
				},
				Parsing: "ArrayLiteral",
				Token:   tk[2],
			}
		}},
		{"[\n...\na\n]", func(t *test, tk Tokens) { // 7
			litA := makeConditionLiteral(tk, 4)
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						Spread: true,
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[4:5],
						},
						Tokens: tk[2:5],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n...\na\nb]", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err:     ErrMissingComma,
				Parsing: "ArrayLiteral",
				Token:   tk[6],
			}
		}},
		{"[\n*\n]", func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err: Error{
					Err:     assignmentError(tk[2]),
					Parsing: "ArrayElement",
					Token:   tk[2],
				},
				Parsing: "ArrayLiteral",
				Token:   tk[2],
			}
		}},
		{"[\na\n]", func(t *test, tk Tokens) { // 10
			litA := makeConditionLiteral(tk, 2)
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[2:3],
					},
				},
				Tokens: tk[:5],
			}
		}},
		{"[\na\nb\n]", func(t *test, tk Tokens) { // 11
			t.Err = Error{
				Err:     ErrMissingComma,
				Parsing: "ArrayLiteral",
				Token:   tk[4],
			}
		}},
		{"[\na\n,\nb\n]", func(t *test, tk Tokens) { // 12
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 6)
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[2:3],
					},
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litB,
							Tokens:                tk[6:7],
						},
						Tokens: tk[6:7],
					},
				},
				Tokens: tk[:9],
			}
		}},
		{"[\na\n,\n,\nb\n,\n,\n...\nc\n]", func(t *test, tk Tokens) { // 13
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 8)
			litC := makeConditionLiteral(tk, 16)
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[2:3],
					},
					{},
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litB,
							Tokens:                tk[8:9],
						},
						Tokens: tk[8:9],
					},
					{},
					{
						Spread: true,
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litC,
							Tokens:                tk[16:17],
						},
						Tokens: tk[14:17],
					},
				},
				Tokens: tk[:19],
			}
		}},
		{"[...a, b]", func(t *test, tk Tokens) { // 14
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 5)
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						Spread: true,
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[1:3],
					},
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: &litB,
							Tokens:                tk[5:6],
						},
						Tokens: tk[5:6],
					},
				},
				Tokens: tk[:7],
			}
		}},
		{"[\n// A\n... // B\na // C\n]", func(t *test, tk Tokens) { // 15
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						Spread: true,
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[8],
									Tokens:              tk[8:9],
								},
								Comments: [5]Comments{{&tk[6]}, nil, nil, nil, {&tk[10]}},
								Tokens:   tk[6:11],
							}),
							Tokens: tk[6:11],
						},
						Comments: Comments{&tk[2]},
						Tokens:   tk[2:11],
					},
				},
				Tokens: tk[:13],
			}
		}},
		{"[ // A\n// B\n\n// C\na // D\n\n// E\n, // F\n\n// G\nb // H\n// I\n\n// J\n]", func(t *test, tk Tokens) { // 16
			t.Output = ArrayLiteral{
				ElementList: []ArrayElement{
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[8],
									Tokens:              tk[8:9],
								},
								Comments: [5]Comments{{&tk[6]}, nil, nil, nil, {&tk[10], &tk[12]}},
								Tokens:   tk[6:13],
							}),
							Tokens: tk[6:13],
						},
						Tokens: tk[6:13],
					},
					{
						AssignmentExpression: AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[20],
									Tokens:              tk[20:21],
								},
								Comments: [5]Comments{{&tk[16], &tk[18]}, nil, nil, nil, {&tk[22], &tk[24]}},
								Tokens:   tk[16:25],
							}),
							Tokens: tk[16:25],
						},
						Tokens: tk[16:25],
					},
				},
				Comments: [2]Comments{{&tk[2], &tk[4]}, {&tk[26]}},
				Tokens:   tk[:29],
			}
		}},
	}, func(t *test) (Type, error) {
		var al ArrayLiteral

		err := al.parse(&t.Tokens, t.Yield, t.Await)

		return al, err
	})
}

func TestObjectLiteral(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrMissingOpeningBrace,
				Parsing: "ObjectLiteral",
				Token:   tk[0],
			}
		}},
		{`[]`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err:     ErrMissingOpeningBrace,
				Parsing: "ObjectLiteral",
				Token:   tk[0],
			}
		}},
		{"{\n}", func(t *test, tk Tokens) { // 3
			t.Output = ObjectLiteral{
				Tokens: tk[:3],
			}
		}},
		{"{\n,\n}", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrInvalidPropertyName,
						Parsing: "PropertyName",
						Token:   tk[2],
					},
					Parsing: "PropertyDefinition",
					Token:   tk[2],
				},
				Parsing: "ObjectLiteral",
				Token:   tk[2],
			}
		}},
		{"{\na\n}", func(t *test, tk Tokens) { // 5
			litA := makeConditionLiteral(tk, 2)
			t.Output = ObjectLiteral{
				PropertyDefinitionList: []PropertyDefinition{
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[2:3],
					},
				},
				Tokens: tk[:5],
			}
		}},
		{"{\n...a\nb\n}", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err:     ErrMissingComma,
				Parsing: "ObjectLiteral",
				Token:   tk[5],
			}
		}},
		{"{\na\n,\nb\n}", func(t *test, tk Tokens) { // 7
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 6)
			t.Output = ObjectLiteral{
				PropertyDefinitionList: []PropertyDefinition{
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: &litA,
							Tokens:                tk[2:3],
						},
						Tokens: tk[2:3],
					},
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[6],
							Tokens:              tk[6:7],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: &litB,
							Tokens:                tk[6:7],
						},
						Tokens: tk[6:7],
					},
				},
				Tokens: tk[:9],
			}
		}},
		{"{ // A\n// B\n\n// C\n}", func(t *test, tk Tokens) { // 8
			t.Output = ObjectLiteral{
				Comments: [2]Comments{{&tk[2], &tk[4]}, {&tk[6]}},
				Tokens:   tk[:9],
			}
		}},
		{"{ // A\n// B\n\n// C\na // D\n// E\n\n// F\n}", func(t *test, tk Tokens) { // 9
			t.Output = ObjectLiteral{
				PropertyDefinitionList: []PropertyDefinition{
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[8],
							Tokens:              tk[8:9],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[8],
									Tokens:              tk[8:9],
								},
								Tokens: tk[8:9],
							}),
							Tokens: tk[8:9],
						},
						Comments: [2]Comments{{&tk[6]}, {&tk[10], &tk[12]}},
						Tokens:   tk[6:13],
					},
				},
				Comments: [2]Comments{{&tk[2], &tk[4]}, {&tk[14]}},
				Tokens:   tk[:17],
			}
		}},
		{"{ // A\n\n// B\na // C\n, // D\nb // E\n\n// F\n}", func(t *test, tk Tokens) { // 10
			t.Output = ObjectLiteral{
				PropertyDefinitionList: []PropertyDefinition{
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[6],
							Tokens:              tk[6:7],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[6],
									Tokens:              tk[6:7],
								},
								Tokens: tk[6:7],
							}),
							Tokens: tk[6:7],
						},
						Comments: [2]Comments{{&tk[4]}, {&tk[8]}},
						Tokens:   tk[4:9],
					},
					{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[14],
							Tokens:              tk[14:15],
						},
						AssignmentExpression: &AssignmentExpression{
							ConditionalExpression: WrapConditional(&MemberExpression{
								PrimaryExpression: &PrimaryExpression{
									IdentifierReference: &tk[14],
									Tokens:              tk[14:15],
								},
								Tokens: tk[14:15],
							}),
							Tokens: tk[14:15],
						},
						Comments: [2]Comments{{&tk[12]}, {&tk[16]}},
						Tokens:   tk[12:17],
					},
				},
				Comments: [2]Comments{{&tk[2]}, {&tk[18]}},
				Tokens:   tk[:21],
			}
		}},
	}, func(t *test) (Type, error) {
		var ol ObjectLiteral

		err := ol.parse(&t.Tokens, t.Yield, t.Await)

		return ol, err
	})
}

func TestPropertyDefinition(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err: Error{
					Err:     ErrInvalidPropertyName,
					Parsing: "PropertyName",
					Token:   tk[0],
				},
				Parsing: "PropertyDefinition",
				Token:   tk[0],
			}
		}},
		{`...`, func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err:     assignmentError(tk[1]),
				Parsing: "PropertyDefinition",
				Token:   tk[1],
			}
		}},
		{"...\na", func(t *test, tk Tokens) { // 3
			litA := makeConditionLiteral(tk, 2)
			t.Output = PropertyDefinition{
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litA,
					Tokens:                tk[2:3],
				},
				Tokens: tk[:3],
			}
		}},
		{"a\n,", func(t *test, tk Tokens) { // 4
			litA := makeConditionLiteral(tk, 0)
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litA,
					Tokens:                tk[:1],
				},
				Tokens: tk[:1],
			}
		}},
		{"{\na\n}", func(t *test, tk Tokens) { // 5
			litA := makeConditionLiteral(tk, 2)
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litA,
					Tokens:                tk[2:3],
				},
				Tokens: tk[2:3],
			}
			t.Tokens = jsParser(tk[2:2])
		}},
		{"a\n=\n", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err:     assignmentError(tk[4]),
				Parsing: "PropertyDefinition",
				Token:   tk[4],
			}
		}},
		{"a\n=\nb", func(t *test, tk Tokens) { // 7
			litB := makeConditionLiteral(tk, 4)
			t.Output = PropertyDefinition{
				IsCoverInitializedName: true,
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[4:5],
				},
				Tokens: tk[:5],
			}
		}},
		{"a\n:\n", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err:     assignmentError(tk[4]),
				Parsing: "PropertyDefinition",
				Token:   tk[4],
			}
		}},
		{"a\n:\nb", func(t *test, tk Tokens) { // 9
			litB := makeConditionLiteral(tk, 4)
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[0],
					Tokens:              tk[:1],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[4:5],
				},
				Tokens: tk[:5],
			}
		}},
		{"[\na\n]\n:\nb", func(t *test, tk Tokens) { // 10
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 8)
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					ComputedPropertyName: &AssignmentExpression{
						ConditionalExpression: &litA,
						Tokens:                tk[2:3],
					},
					Tokens: tk[:5],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[8:9],
				},
				Tokens: tk[:9],
			}
		}},
		{"[\na\n]\n", func(t *test, tk Tokens) { // 11
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrMissingOpeningParenthesis,
						Parsing: "FormalParameters",
						Token:   tk[6],
					},
					Parsing: "MethodDefinition",
					Token:   tk[6],
				},
				Parsing: "PropertyDefinition",
				Token:   tk[0],
			}
		}},
		{"a\n(){}", func(t *test, tk Tokens) { // 12
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[0],
							Tokens:              tk[:1],
						},
						Tokens: tk[:1],
					},
					Params: FormalParameters{
						Tokens: tk[2:4],
					},
					FunctionBody: Block{
						Tokens: tk[4:6],
					},
					Tokens: tk[:6],
				},
				Tokens: tk[:6],
			}
		}},
		{"*\na\n(){}", func(t *test, tk Tokens) { // 13
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					Type: MethodGenerator,
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						Tokens: tk[2:3],
					},
					Params: FormalParameters{
						Tokens: tk[4:6],
					},
					FunctionBody: Block{
						Tokens: tk[6:8],
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"async a\n(){}", func(t *test, tk Tokens) { // 14
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					Type: MethodAsync,
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						Tokens: tk[2:3],
					},
					Params: FormalParameters{
						Tokens: tk[4:6],
					},
					FunctionBody: Block{
						Tokens: tk[6:8],
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"get\na\n(){}", func(t *test, tk Tokens) { // 15
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					Type: MethodGetter,
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						Tokens: tk[2:3],
					},
					Params: FormalParameters{
						Tokens: tk[4:6],
					},
					FunctionBody: Block{
						Tokens: tk[6:8],
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"set\na\n(b){}", func(t *test, tk Tokens) { // 16
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					Type: MethodSetter,
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						Tokens: tk[2:3],
					},
					Params: FormalParameters{
						FormalParameterList: []BindingElement{
							{
								SingleNameBinding: &tk[5],
								Tokens:            tk[5:6],
							},
						},
						Tokens: tk[4:7],
					},
					FunctionBody: Block{
						Tokens: tk[7:9],
					},
					Tokens: tk[:9],
				},
				Tokens: tk[:9],
			}
		}},
		{"[\n\"a\"\n]\n()\n{}", func(t *test, tk Tokens) { // 17
			litA := makeConditionLiteral(tk, 2)
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							ComputedPropertyName: &AssignmentExpression{
								ConditionalExpression: &litA,
								Tokens:                tk[2:3],
							},
							Tokens: tk[:5],
						},
						Tokens: tk[:5],
					},
					Params: FormalParameters{
						Tokens: tk[6:8],
					},
					FunctionBody: Block{
						Tokens: tk[9:11],
					},
					Tokens: tk[:11],
				},
				Tokens: tk[:11],
			}
		}},
		{"async/* */a (){}", func(t *test, tk Tokens) { // 18
			t.Output = PropertyDefinition{
				MethodDefinition: &MethodDefinition{
					Type: MethodAsync,
					ClassElementName: ClassElementName{
						PropertyName: &PropertyName{
							LiteralPropertyName: &tk[2],
							Tokens:              tk[2:3],
						},
						Comments: [2]Comments{{&tk[1]}},
						Tokens:   tk[1:3],
					},
					Params: FormalParameters{
						Tokens: tk[4:6],
					},
					FunctionBody: Block{
						Tokens: tk[6:8],
					},
					Tokens: tk[:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"async/*\n*/a (){}", func(t *test, tk Tokens) { // 19
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrMissingOpeningParenthesis,
						Parsing: "FormalParameters",
						Token:   tk[2],
					},
					Parsing: "MethodDefinition",
					Token:   tk[2],
				},
				Parsing: "PropertyDefinition",
				Token:   tk[0],
			}
		}},
		{"// A\n... // B\na // C", func(t *test, tk Tokens) { // 20
			t.Output = PropertyDefinition{
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[6],
							Tokens:              tk[6:7],
						},
						Comments: [5]Comments{{&tk[4]}, nil, nil, nil, {&tk[8]}},
						Tokens:   tk[4:9],
					}),
					Tokens: tk[4:9],
				},
				Comments: [2]Comments{{&tk[0]}},
				Tokens:   tk[:9],
			}
		}},
		{"// A\na // B\n,", func(t *test, tk Tokens) { // 21
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[2],
							Tokens:              tk[2:3],
						},
						Tokens: tk[2:3],
					}),
					Tokens: tk[2:3],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:5],
			}
		}},
		{"// A\na // B\n= // C\nb // D\n", func(t *test, tk Tokens) { // 22
			t.Output = PropertyDefinition{
				IsCoverInitializedName: true,
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[10],
							Tokens:              tk[10:11],
						},
						Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
						Tokens:   tk[8:13],
					}),
					Tokens: tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
		{"// A\na // B\n: // C\nb // D", func(t *test, tk Tokens) { // 23
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					LiteralPropertyName: &tk[2],
					Tokens:              tk[2:3],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[10],
							Tokens:              tk[10:11],
						},
						Comments: [5]Comments{{&tk[8]}, nil, nil, nil, {&tk[12]}},
						Tokens:   tk[8:13],
					}),
					Tokens: tk[8:13],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[4]}},
				Tokens:   tk[:13],
			}
		}},
		{"// A\n[ // B\na\n// C\n] // D\n: // E\nb // F\n", func(t *test, tk Tokens) { // 24
			t.Output = PropertyDefinition{
				PropertyName: &PropertyName{
					ComputedPropertyName: &AssignmentExpression{
						ConditionalExpression: WrapConditional(&MemberExpression{
							PrimaryExpression: &PrimaryExpression{
								IdentifierReference: &tk[6],
								Tokens:              tk[6:7],
							},
							Tokens: tk[6:7],
						}),
						Tokens: tk[6:7],
					},
					Comments: [2]Comments{{&tk[4]}, {&tk[8]}},
					Tokens:   tk[2:11],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[18],
							Tokens:              tk[18:19],
						},
						Comments: [5]Comments{{&tk[16]}, nil, nil, nil, {&tk[20]}},
						Tokens:   tk[16:21],
					}),
					Tokens: tk[16:21],
				},
				Comments: [2]Comments{{&tk[0]}, {&tk[12]}},
				Tokens:   tk[:21],
			}
		}},
	}, func(t *test) (Type, error) {
		var pd PropertyDefinition

		err := pd.parse(&t.Tokens, t.Yield, t.Await)

		return pd, err
	})
}

func TestTemplateLiteral(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrInvalidTemplate,
				Parsing: "TemplateLiteral",
				Token:   tk[0],
			}
		}},
		{"``", func(t *test, tk Tokens) { // 2
			t.Output = TemplateLiteral{
				NoSubstitutionTemplate: &tk[0],
				Tokens:                 tk[:1],
			}
		}},
		{"`${\na\n}`", func(t *test, tk Tokens) { // 3
			litA := makeConditionLiteral(tk, 2)
			t.Output = TemplateLiteral{
				TemplateHead: &tk[0],
				Expressions: []Expression{
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litA,
								Tokens:                tk[2:3],
							},
						},
						Tokens: tk[2:3],
					},
				},
				TemplateTail: &tk[4],
				Tokens:       tk[:5],
			}
		}},
		{"`${\na\nb\n}`", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err:     ErrInvalidTemplate,
				Parsing: "TemplateLiteral",
				Token:   tk[4],
			}
		}},
		{"`${\na\n}${\nb\n}`", func(t *test, tk Tokens) { // 5
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 6)
			t.Output = TemplateLiteral{
				TemplateHead: &tk[0],
				Expressions: []Expression{
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litA,
								Tokens:                tk[2:3],
							},
						},
						Tokens: tk[2:3],
					},
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litB,
								Tokens:                tk[6:7],
							},
						},
						Tokens: tk[6:7],
					},
				},
				TemplateMiddleList: []*Token{
					&tk[4],
				},
				TemplateTail: &tk[8],
				Tokens:       tk[:9],
			}
		}},
		{"`${\na\n}${\nb\n}${\nc\n}`", func(t *test, tk Tokens) { // 6
			litA := makeConditionLiteral(tk, 2)
			litB := makeConditionLiteral(tk, 6)
			litC := makeConditionLiteral(tk, 10)
			t.Output = TemplateLiteral{
				TemplateHead: &tk[0],
				Expressions: []Expression{
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litA,
								Tokens:                tk[2:3],
							},
						},
						Tokens: tk[2:3],
					},
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litB,
								Tokens:                tk[6:7],
							},
						},
						Tokens: tk[6:7],
					},
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: &litC,
								Tokens:                tk[10:11],
							},
						},
						Tokens: tk[10:11],
					},
				},
				TemplateMiddleList: []*Token{
					&tk[4],
					&tk[8],
				},
				TemplateTail: &tk[12],
				Tokens:       tk[:13],
			}
		}},
		{"`${,}`", func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err: Error{
					Err:     assignmentError(tk[1]),
					Parsing: "Expression",
					Token:   tk[1],
				},
				Parsing: "TemplateLiteral",
				Token:   tk[1],
			}
		}},
		{"`${ // A\n\n// B\na // C\n\n// D\n}`", func(t *test, tk Tokens) { // 8
			t.Output = TemplateLiteral{
				TemplateHead: &tk[0],
				Expressions: []Expression{
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: WrapConditional(&MemberExpression{
									PrimaryExpression: &PrimaryExpression{
										IdentifierReference: &tk[6],
										Tokens:              tk[6:7],
									},
									Comments: [5]Comments{{&tk[2], &tk[4]}, nil, nil, nil, {&tk[8], &tk[10]}},
									Tokens:   tk[2:11],
								}),
								Tokens: tk[2:11],
							},
						},
						Tokens: tk[2:11],
					},
				},
				TemplateTail: &tk[12],
				Tokens:       tk[:13],
			}
		}},
		{"`${ // A\na // B\n\n// C\n}${ // D\nb // E\n}`", func(t *test, tk Tokens) { // 9
			t.Output = TemplateLiteral{
				TemplateHead: &tk[0],
				Expressions: []Expression{
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: WrapConditional(&MemberExpression{
									PrimaryExpression: &PrimaryExpression{
										IdentifierReference: &tk[4],
										Tokens:              tk[4:5],
									},
									Comments: [5]Comments{{&tk[2]}, nil, nil, nil, {&tk[6], &tk[8]}},
									Tokens:   tk[2:9],
								}),
								Tokens: tk[2:9],
							},
						},
						Tokens: tk[2:9],
					},
					{
						Expressions: []AssignmentExpression{
							{
								ConditionalExpression: WrapConditional(&MemberExpression{
									PrimaryExpression: &PrimaryExpression{
										IdentifierReference: &tk[14],
										Tokens:              tk[14:15],
									},
									Comments: [5]Comments{{&tk[12]}, nil, nil, nil, {&tk[16]}},
									Tokens:   tk[12:17],
								}),
								Tokens: tk[12:17],
							},
						},
						Tokens: tk[12:17],
					},
				},
				TemplateMiddleList: []*Token{
					&tk[10],
				},
				TemplateTail: &tk[18],
				Tokens:       tk[:19],
			}
		}},
	}, func(t *test) (Type, error) {
		var tl TemplateLiteral

		err := tl.parse(&t.Tokens, t.Yield, t.Await)

		return tl, err
	})
}

func TestArrowFunction(t *testing.T) {
	doTests(t, []sourceFn{
		{``, func(t *test, tk Tokens) { // 1
			t.Err = Error{
				Err:     ErrNoIdentifier,
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"async (\nnull\n)", func(t *test, tk Tokens) { // 2
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "BindingElement",
						Token:   tk[4],
					},
					Parsing: "FormalParameters",
					Token:   tk[4],
				},
				Parsing: "ArrowFunction",
				Token:   tk[2],
			}
		}},
		{"async (\n...\na\nb)", func(t *test, tk Tokens) { // 3
			t.Err = Error{
				Err: Error{
					Err:     ErrMissingClosingParenthesis,
					Parsing: "FormalParameters",
					Token:   tk[8],
				},
				Parsing: "ArrowFunction",
				Token:   tk[2],
			}
		}},
		{"async", func(t *test, tk Tokens) { // 4
			t.Err = Error{
				Err:     ErrNoIdentifier,
				Parsing: "ArrowFunction",
				Token:   tk[1],
			}
		}},
		{"async\n", func(t *test, tk Tokens) { // 5
			t.Err = Error{
				Err:     ErrNoIdentifier,
				Parsing: "ArrowFunction",
				Token:   tk[1],
			}
		}},
		{"a\n", func(t *test, tk Tokens) { // 6
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[1],
			}
		}},
		{"a ", func(t *test, tk Tokens) { // 7
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[2],
			}
		}},
		{"(a)\n", func(t *test, tk Tokens) { // 8
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[3],
			}
		}},
		{"(a) ", func(t *test, tk Tokens) { // 9
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[4],
			}
		}},
		{"async a\n", func(t *test, tk Tokens) { // 10
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[3],
			}
		}},
		{"async a ", func(t *test, tk Tokens) { // 11
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[4],
			}
		}},
		{"async (a)\n", func(t *test, tk Tokens) { // 12
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[5],
			}
		}},
		{"async (a) ", func(t *test, tk Tokens) { // 13
			t.Err = Error{
				Err:     ErrMissingArrow,
				Parsing: "ArrowFunction",
				Token:   tk[6],
			}
		}},
		{"a=>{:}", func(t *test, tk Tokens) { // 14
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err:     assignmentError(tk[3]),
								Parsing: "Expression",
								Token:   tk[3],
							},
							Parsing: "Statement",
							Token:   tk[3],
						},
						Parsing: "StatementListItem",
						Token:   tk[3],
					},
					Parsing: "Block",
					Token:   tk[3],
				},
				Parsing: "ArrowFunction",
				Token:   tk[2],
			}
		}},
		{"a =>\n{}", func(t *test, tk Tokens) { // 15
			t.Output = ArrowFunction{
				BindingIdentifier: &tk[0],
				FunctionBody: &Block{
					Tokens: tk[4:6],
				},
				Tokens: tk[:6],
			}
		}},
		{"() =>\n{}", func(t *test, tk Tokens) { // 16
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					Tokens: tk[:2],
				},
				FunctionBody: &Block{
					Tokens: tk[5:7],
				},
				Tokens: tk[:7],
			}
		}},
		{"async a =>\n{}", func(t *test, tk Tokens) { // 17
			t.Output = ArrowFunction{
				Async:             true,
				BindingIdentifier: &tk[2],
				FunctionBody: &Block{
					Tokens: tk[6:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"async () =>\n{}", func(t *test, tk Tokens) { // 18
			t.Output = ArrowFunction{
				Async: true,
				FormalParameters: &FormalParameters{
					Tokens: tk[2:4],
				},
				FunctionBody: &Block{
					Tokens: tk[7:9],
				},
				Tokens: tk[:9],
			}
		}},
		{"a=>:", func(t *test, tk Tokens) { // 19
			t.Err = Error{
				Err:     assignmentError(tk[2]),
				Parsing: "ArrowFunction",
				Token:   tk[2],
			}
		}},
		{"a =>\nb", func(t *test, tk Tokens) { // 20
			litB := makeConditionLiteral(tk, 4)
			t.Output = ArrowFunction{
				BindingIdentifier: &tk[0],
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[4:5],
				},
				Tokens: tk[:5],
			}
		}},
		{"() =>\nb", func(t *test, tk Tokens) { // 21
			litB := makeConditionLiteral(tk, 5)
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					Tokens: tk[:2],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[5:6],
				},
				Tokens: tk[:6],
			}
		}},
		{"async a =>\nb", func(t *test, tk Tokens) { // 22
			litB := makeConditionLiteral(tk, 6)
			t.Output = ArrowFunction{
				Async:             true,
				BindingIdentifier: &tk[2],
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[6:7],
				},
				Tokens: tk[:7],
			}
		}},
		{"async () =>\nb", func(t *test, tk Tokens) { // 23
			litB := makeConditionLiteral(tk, 7)
			t.Output = ArrowFunction{
				Async: true,
				FormalParameters: &FormalParameters{
					Tokens: tk[2:4],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[7:8],
				},
				Tokens: tk[:8],
			}
		}},
		{"([a]) => a", func(t *test, tk Tokens) { // 24
			litAb := makeConditionLiteral(tk, 8)
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingElementList: []BindingElement{
									{
										SingleNameBinding: &tk[2],
										Tokens:            tk[2:3],
									},
								},
								Tokens: tk[1:4],
							},
							Tokens: tk[1:4],
						},
					},
					Tokens: tk[:5],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litAb,
					Tokens:                tk[8:9],
				},
				Tokens: tk[:9],
			}
		}},
		{"({a}) => a", func(t *test, tk Tokens) { // 25
			litAb := makeConditionLiteral(tk, 8)
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											SingleNameBinding: &tk[2],
											Tokens:            tk[2:3],
										},
										Tokens: tk[2:3],
									},
								},
								Tokens: tk[1:4],
							},
							Tokens: tk[1:4],
						},
					},
					Tokens: tk[:5],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litAb,
					Tokens:                tk[8:9],
				},
				Tokens: tk[:9],
			}
		}},
		{"([a, {b}, {c: d}, {e, f, ...g}, {h: {i = j}}, ...k], {l: [m, n] = [o, p]}, ...q) => r", func(t *test, tk Tokens) { // 26
			litJ := makeConditionLiteral(tk, 39)
			litR := makeConditionLiteral(tk, 77)
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingElementList: []BindingElement{
									{
										SingleNameBinding: &tk[2],
										Tokens:            tk[2:3],
									},
									{
										ObjectBindingPattern: &ObjectBindingPattern{
											BindingPropertyList: []BindingProperty{
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[6],
														Tokens:              tk[6:7],
													},
													BindingElement: BindingElement{
														SingleNameBinding: &tk[6],
														Tokens:            tk[6:7],
													},
													Tokens: tk[6:7],
												},
											},
											Tokens: tk[5:8],
										},
										Tokens: tk[5:8],
									},
									{
										ObjectBindingPattern: &ObjectBindingPattern{
											BindingPropertyList: []BindingProperty{
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[11],
														Tokens:              tk[11:12],
													},
													BindingElement: BindingElement{
														SingleNameBinding: &tk[14],
														Tokens:            tk[14:15],
													},
													Tokens: tk[11:15],
												},
											},
											Tokens: tk[10:16],
										},
										Tokens: tk[10:16],
									},
									{
										ObjectBindingPattern: &ObjectBindingPattern{
											BindingPropertyList: []BindingProperty{
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[19],
														Tokens:              tk[19:20],
													},
													BindingElement: BindingElement{
														SingleNameBinding: &tk[19],
														Tokens:            tk[19:20],
													},
													Tokens: tk[19:20],
												},
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[22],
														Tokens:              tk[22:23],
													},
													BindingElement: BindingElement{
														SingleNameBinding: &tk[22],
														Tokens:            tk[22:23],
													},
													Tokens: tk[22:23],
												},
											},
											BindingRestProperty: &tk[26],
											Tokens:              tk[18:28],
										},
										Tokens: tk[18:28],
									},
									{
										ObjectBindingPattern: &ObjectBindingPattern{
											BindingPropertyList: []BindingProperty{
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[31],
														Tokens:              tk[31:32],
													},
													BindingElement: BindingElement{
														ObjectBindingPattern: &ObjectBindingPattern{
															BindingPropertyList: []BindingProperty{
																{
																	PropertyName: PropertyName{
																		LiteralPropertyName: &tk[35],
																		Tokens:              tk[35:36],
																	},
																	BindingElement: BindingElement{
																		SingleNameBinding: &tk[35],
																		Initializer: &AssignmentExpression{
																			ConditionalExpression: &litJ,
																			Tokens:                tk[39:40],
																		},
																		Tokens: tk[35:40],
																	},
																	Tokens: tk[35:40],
																},
															},
															Tokens: tk[34:41],
														},
														Tokens: tk[34:41],
													},
													Tokens: tk[31:41],
												},
											},
											Tokens: tk[30:42],
										},
										Tokens: tk[30:42],
									},
								},
								BindingRestElement: &BindingElement{
									SingleNameBinding: &tk[45],
									Tokens:            tk[45:46],
								},
								Tokens: tk[1:47],
							},
							Tokens: tk[1:47],
						},
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[50],
											Tokens:              tk[50:51],
										},
										BindingElement: BindingElement{
											ArrayBindingPattern: &ArrayBindingPattern{
												BindingElementList: []BindingElement{
													{
														SingleNameBinding: &tk[54],
														Tokens:            tk[54:55],
													},
													{
														SingleNameBinding: &tk[57],
														Tokens:            tk[57:58],
													},
												},
												Tokens: tk[53:59],
											},
											Initializer: &AssignmentExpression{
												ConditionalExpression: WrapConditional(&ArrayLiteral{
													ElementList: []ArrayElement{
														{
															AssignmentExpression: AssignmentExpression{
																ConditionalExpression: WrapConditional(&PrimaryExpression{
																	IdentifierReference: &tk[63],
																	Tokens:              tk[63:64],
																}),
																Tokens: tk[63:64],
															},
															Tokens: tk[63:64],
														},
														{
															AssignmentExpression: AssignmentExpression{
																ConditionalExpression: WrapConditional(&PrimaryExpression{
																	IdentifierReference: &tk[66],
																	Tokens:              tk[66:67],
																}),
																Tokens: tk[66:67],
															},
															Tokens: tk[66:67],
														},
													},
													Tokens: tk[62:68],
												}),
												Tokens: tk[62:68],
											},
											Tokens: tk[53:68],
										},
										Tokens: tk[50:68],
									},
								},
								Tokens: tk[49:69],
							},
							Tokens: tk[49:69],
						},
					},
					BindingIdentifier: &tk[72],
					Tokens:            tk[:74],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litR,
					Tokens:                tk[77:78],
				},
				Tokens: tk[:78],
			}
		}},
		{"([, a]) => b", func(t *test, tk Tokens) { // 27
			litB := makeConditionLiteral(tk, 10)
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingElementList: []BindingElement{
									{
										Tokens: tk[2:2],
									},
									{
										SingleNameBinding: &tk[4],
										Tokens:            tk[4:5],
									},
								},
								Tokens: tk[1:6],
							},
							Tokens: tk[1:6],
						},
					},
					Tokens: tk[0:7],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: &litB,
					Tokens:                tk[10:11],
				},
				Tokens: tk[:11],
			}
		}},
		{"(()=>a) => b", func(t *test, tk Tokens) { // 28
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"(a/=b) => b", func(t *test, tk Tokens) { // 29
			t.Err = Error{
				Err: Error{
					Err:     ErrMissingComma,
					Parsing: "FormalParameters",
					Token:   tk[2],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"([a /= b]) => 1", func(t *test, tk Tokens) { // 30
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingComma,
							Parsing: "ArrayBindingPattern",
							Token:   tk[4],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"([...a /= b]) => 1", func(t *test, tk Tokens) { // 31
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingClosingBracket,
							Parsing: "ArrayBindingPattern",
							Token:   tk[5],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a() {}}) => 1", func(t *test, tk Tokens) { // 32
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingComma,
							Parsing: "ObjectBindingPattern",
							Token:   tk[3],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a: b /= 1}) => 1", func(t *test, tk Tokens) { // 33
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingComma,
							Parsing: "ObjectBindingPattern",
							Token:   tk[7],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({...a=>1}) => 1", func(t *test, tk Tokens) { // 34
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingClosingBrace,
							Parsing: "ObjectBindingPattern",
							Token:   tk[4],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"(``) => 1", func(t *test, tk Tokens) { // 35
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"(`` = 1) => 1", func(t *test, tk Tokens) { // 36
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err:     ErrNoIdentifier,
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"([`` = 1] = 1) => 1", func(t *test, tk Tokens) { // 37
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err:     ErrNoIdentifier,
								Parsing: "BindingElement",
								Token:   tk[2],
							},
							Parsing: "ArrayBindingPattern",
							Token:   tk[2],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({} = {}) => 1", func(t *test, tk Tokens) { // 38
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								Tokens: tk[1:3],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[6:8],
								}),
								Tokens: tk[6:8],
							},
							Tokens: tk[1:8],
						},
					},
					Tokens: tk[:9],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[12],
						Tokens:  tk[12:13],
					}),
					Tokens: tk[12:13],
				},
				Tokens: tk[:13],
			}
		}},
		{"([...a] = []) => 1", func(t *test, tk Tokens) { // 39
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingRestElement: &BindingElement{
									SingleNameBinding: &tk[3],
									Tokens:            tk[3:4],
								},
								Tokens: tk[1:5],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ArrayLiteral{
									Tokens: tk[8:10],
								}),
								Tokens: tk[8:10],
							},
							Tokens: tk[1:10],
						},
					},
					Tokens: tk[:11],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[14],
						Tokens:  tk[14:15],
					}),
					Tokens: tk[14:15],
				},
				Tokens: tk[:15],
			}
		}},
		{"([...a.b] = []) => 1", func(t *test, tk Tokens) { // 40
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingClosingBracket,
							Parsing: "ArrayBindingPattern",
							Token:   tk[4],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a} = {}) => 1", func(t *test, tk Tokens) { // 41
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											SingleNameBinding: &tk[2],
											Tokens:            tk[2:3],
										},
										Tokens: tk[2:3],
									},
								},
								Tokens: tk[1:4],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[7:9],
								}),
								Tokens: tk[7:9],
							},
							Tokens: tk[1:9],
						},
					},
					Tokens: tk[:10],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[13],
						Tokens:  tk[13:14],
					}),
					Tokens: tk[13:14],
				},
				Tokens: tk[:14],
			}
		}},
		{"({a: a.b} = {}) => 1", func(t *test, tk Tokens) { // 42
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingComma,
							Parsing: "ObjectBindingPattern",
							Token:   tk[6],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({...a} = {}) => 1", func(t *test, tk Tokens) { // 43
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingRestProperty: &tk[3],
								Tokens:              tk[1:5],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[8:10],
								}),
								Tokens: tk[8:10],
							},
							Tokens: tk[1:10],
						},
					},
					Tokens: tk[:11],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[14],
						Tokens:  tk[14:15],
					}),
					Tokens: tk[14:15],
				},
				Tokens: tk[:15],
			}
		}},
		{"({...a.b} = {}) => 1", func(t *test, tk Tokens) { // 44
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingClosingBrace,
							Parsing: "ObjectBindingPattern",
							Token:   tk[4],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a: []} = {}) => 1", func(t *test, tk Tokens) { // 45
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											ArrayBindingPattern: &ArrayBindingPattern{
												Tokens: tk[5:7],
											},
											Tokens: tk[5:7],
										},
										Tokens: tk[2:7],
									},
								},
								Tokens: tk[1:8],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[11:13],
								}),
								Tokens: tk[11:13],
							},
							Tokens: tk[1:13],
						},
					},
					Tokens: tk[:14],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[17],
						Tokens:  tk[17:18],
					}),
					Tokens: tk[17:18],
				},
				Tokens: tk[:18],
			}
		}},
		{"({a: [b.c]} = {}) => 1", func(t *test, tk Tokens) { // 46
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err: Error{
									Err: Error{
										Err:     ErrMissingComma,
										Parsing: "ArrayBindingPattern",
										Token:   tk[7],
									},
									Parsing: "BindingElement",
									Token:   tk[5],
								},
								Parsing: "BindingProperty",
								Token:   tk[5],
							},
							Parsing: "ObjectBindingPattern",
							Token:   tk[2],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a: {}} = {}) => 1", func(t *test, tk Tokens) { // 47
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											ObjectBindingPattern: &ObjectBindingPattern{
												Tokens: tk[5:7],
											},
											Tokens: tk[5:7],
										},
										Tokens: tk[2:7],
									},
								},
								Tokens: tk[1:8],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[11:13],
								}),
								Tokens: tk[11:13],
							},
							Tokens: tk[1:13],
						},
					},
					Tokens: tk[:14],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[17],
						Tokens:  tk[17:18],
					}),
					Tokens: tk[17:18],
				},
				Tokens: tk[:18],
			}
		}},
		{"({a: {b: c.d}} = {}) => 1", func(t *test, tk Tokens) { // 48
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err: Error{
									Err: Error{
										Err:     ErrMissingComma,
										Parsing: "ObjectBindingPattern",
										Token:   tk[10],
									},
									Parsing: "BindingElement",
									Token:   tk[5],
								},
								Parsing: "BindingProperty",
								Token:   tk[5],
							},
							Parsing: "ObjectBindingPattern",
							Token:   tk[2],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a: {b = 1}} = {}) => 2", func(t *test, tk Tokens) { // 49
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											ObjectBindingPattern: &ObjectBindingPattern{
												BindingPropertyList: []BindingProperty{
													{
														PropertyName: PropertyName{
															LiteralPropertyName: &tk[6],
															Tokens:              tk[6:7],
														},
														BindingElement: BindingElement{
															SingleNameBinding: &tk[6],
															Initializer: &AssignmentExpression{
																ConditionalExpression: WrapConditional(&PrimaryExpression{
																	Literal: &tk[10],
																	Tokens:  tk[10:11],
																}),
																Tokens: tk[10:11],
															},
															Tokens: tk[6:11],
														},
														Tokens: tk[6:11],
													},
												},
												Tokens: tk[5:12],
											},
											Tokens: tk[5:12],
										},
										Tokens: tk[2:12],
									},
								},
								Tokens: tk[1:13],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[16:18],
								}),
								Tokens: tk[16:18],
							},
							Tokens: tk[1:18],
						},
					},
					Tokens: tk[:19],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[22],
						Tokens:  tk[22:23],
					}),
					Tokens: tk[22:23],
				},
				Tokens: tk[:23],
			}
		}},
		{"([[a] = []] = []) => 1", func(t *test, tk Tokens) { // 50
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingElementList: []BindingElement{
									{
										ArrayBindingPattern: &ArrayBindingPattern{
											BindingElementList: []BindingElement{
												{
													SingleNameBinding: &tk[3],
													Tokens:            tk[3:4],
												},
											},
											Tokens: tk[2:5],
										},
										Initializer: &AssignmentExpression{
											ConditionalExpression: WrapConditional(&ArrayLiteral{
												Tokens: tk[8:10],
											}),
											Tokens: tk[8:10],
										},
										Tokens: tk[2:10],
									},
								},
								Tokens: tk[1:11],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ArrayLiteral{
									Tokens: tk[14:16],
								}),
								Tokens: tk[14:16],
							},
							Tokens: tk[1:16],
						},
					},
					Tokens: tk[:17],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[20],
						Tokens:  tk[20:21],
					}),
					Tokens: tk[20:21],
				},
				Tokens: tk[:21],
			}
		}},
		{"([[a.b] = []] = []) => 1", func(t *test, tk Tokens) { // 51
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err: Error{
									Err:     ErrMissingComma,
									Parsing: "ArrayBindingPattern",
									Token:   tk[4],
								},
								Parsing: "BindingElement",
								Token:   tk[2],
							},
							Parsing: "ArrayBindingPattern",
							Token:   tk[2],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"({a: {b: c = 1} = {}} = {}) => 2", func(t *test, tk Tokens) { // 52
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ObjectBindingPattern: &ObjectBindingPattern{
								BindingPropertyList: []BindingProperty{
									{
										PropertyName: PropertyName{
											LiteralPropertyName: &tk[2],
											Tokens:              tk[2:3],
										},
										BindingElement: BindingElement{
											ObjectBindingPattern: &ObjectBindingPattern{
												BindingPropertyList: []BindingProperty{
													{
														PropertyName: PropertyName{
															LiteralPropertyName: &tk[6],
															Tokens:              tk[6:7],
														},
														BindingElement: BindingElement{
															SingleNameBinding: &tk[9],
															Initializer: &AssignmentExpression{
																ConditionalExpression: WrapConditional(&PrimaryExpression{
																	Literal: &tk[13],
																	Tokens:  tk[13:14],
																}),
																Tokens: tk[13:14],
															},
															Tokens: tk[9:14],
														},
														Tokens: tk[6:14],
													},
												},
												Tokens: tk[5:15],
											},
											Initializer: &AssignmentExpression{
												ConditionalExpression: WrapConditional(&ObjectLiteral{
													Tokens: tk[18:20],
												}),
												Tokens: tk[18:20],
											},
											Tokens: tk[5:20],
										},
										Tokens: tk[2:20],
									},
								},
								Tokens: tk[1:21],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ObjectLiteral{
									Tokens: tk[24:26],
								}),
								Tokens: tk[24:26],
							},
							Tokens: tk[1:26],
						},
					},
					Tokens: tk[:27],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[30],
						Tokens:  tk[30:31],
					}),
					Tokens: tk[30:31],
				},
				Tokens: tk[:31],
			}
		}},
		{"([{a: b} = {}] = []) => 1", func(t *test, tk Tokens) { // 53
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					FormalParameterList: []BindingElement{
						{
							ArrayBindingPattern: &ArrayBindingPattern{
								BindingElementList: []BindingElement{
									{
										ObjectBindingPattern: &ObjectBindingPattern{
											BindingPropertyList: []BindingProperty{
												{
													PropertyName: PropertyName{
														LiteralPropertyName: &tk[3],
														Tokens:              tk[3:4],
													},
													BindingElement: BindingElement{
														SingleNameBinding: &tk[6],
														Tokens:            tk[6:7],
													},
													Tokens: tk[3:7],
												},
											},
											Tokens: tk[2:8],
										},
										Initializer: &AssignmentExpression{
											ConditionalExpression: WrapConditional(&ObjectLiteral{
												Tokens: tk[11:13],
											}),
											Tokens: tk[11:13],
										},
										Tokens: tk[2:13],
									},
								},
								Tokens: tk[1:14],
							},
							Initializer: &AssignmentExpression{
								ConditionalExpression: WrapConditional(&ArrayLiteral{
									Tokens: tk[17:19],
								}),
								Tokens: tk[17:19],
							},
							Tokens: tk[1:19],
						},
					},
					Tokens: tk[:20],
				},
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&PrimaryExpression{
						Literal: &tk[23],
						Tokens:  tk[23:24],
					}),
					Tokens: tk[23:24],
				},
				Tokens: tk[:24],
			}
		}},
		{"([{a: b.c} = {}] = []) => 1", func(t *test, tk Tokens) { // 54
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err: Error{
								Err: Error{
									Err:     ErrMissingComma,
									Parsing: "ObjectBindingPattern",
									Token:   tk[7],
								},
								Parsing: "BindingElement",
								Token:   tk[2],
							},
							Parsing: "ArrayBindingPattern",
							Token:   tk[2],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"([...a, ...b]) => 1", func(t *test, tk Tokens) { // 55
			t.Err = Error{
				Err: Error{
					Err: Error{
						Err: Error{
							Err:     ErrMissingClosingBracket,
							Parsing: "ArrayBindingPattern",
							Token:   tk[4],
						},
						Parsing: "BindingElement",
						Token:   tk[1],
					},
					Parsing: "FormalParameters",
					Token:   tk[1],
				},
				Parsing: "ArrowFunction",
				Token:   tk[0],
			}
		}},
		{"// A\na /* B */ => // C\n{} // D\n", func(t *test, tk Tokens) { // 56
			t.Output = ArrowFunction{
				BindingIdentifier: &tk[2],
				FunctionBody: &Block{
					Tokens: tk[10:12],
				},
				Comments: [5]Comments{{&tk[0]}, nil, {&tk[4]}, {&tk[8]}, {&tk[13]}},
				Tokens:   tk[:14],
			}
		}},
		{"// A\n() /* B */ => /* C */ {} // D", func(t *test, tk Tokens) { // 57
			t.Output = ArrowFunction{
				FormalParameters: &FormalParameters{
					Tokens: tk[2:4],
				},
				FunctionBody: &Block{
					Tokens: tk[11:13],
				},
				Comments: [5]Comments{{&tk[0]}, nil, {&tk[5]}, {&tk[9]}, {&tk[14]}},
				Tokens:   tk[:15],
			}
		}},
		{"// A\nasync /* B */ a /* C */ => // D\nb // E", func(t *test, tk Tokens) { // 58
			t.Output = ArrowFunction{
				Async:             true,
				BindingIdentifier: &tk[6],
				AssignmentExpression: &AssignmentExpression{
					ConditionalExpression: WrapConditional(&MemberExpression{
						PrimaryExpression: &PrimaryExpression{
							IdentifierReference: &tk[14],
							Tokens:              tk[14:15],
						},
						Comments: [5]Comments{nil, nil, nil, nil, {&tk[16]}},
						Tokens:   tk[14:17],
					}),
					Tokens: tk[14:17],
				},
				Comments: [5]Comments{{&tk[0]}, {&tk[4]}, {&tk[8]}, {&tk[12]}},
				Tokens:   tk[:17],
			}
		}},
		{"// A\nasync /* B */ ()/* C */ => // D\n{}// E\n", func(t *test, tk Tokens) { // 59
			t.Output = ArrowFunction{
				Async: true,
				FormalParameters: &FormalParameters{
					Tokens: tk[6:8],
				},
				FunctionBody: &Block{
					Tokens: tk[14:16],
				},
				Comments: [5]Comments{{&tk[0]}, {&tk[4]}, {&tk[8]}, {&tk[12]}, {&tk[16]}},
				Tokens:   tk[:17],
			}
		}},
	}, func(t *test) (Type, error) {
		var af ArrowFunction

		err := af.parse(&t.Tokens, t.In, t.Yield, t.Await)

		return af, err
	})
}

func TestScriptToModule(t *testing.T) {
	source := `const a = 1;alert(a)`
	s, _ := ParseScript(makeTokeniser(parser.NewStringTokeniser(source)))
	m, _ := ParseModule(makeTokeniser(parser.NewStringTokeniser(source)))

	if sm := ScriptToModule(s); !reflect.DeepEqual(sm, m) {
		t.Errorf("expecting module %v, got %v", m, sm)
	}
}

func TestErrUnwrap(t *testing.T) {
	err := Error{
		Err: Error{
			Err: Error{
				Err:     ErrBadRestElement,
				Parsing: "NonLocalStatement",
			},
			Parsing: "Expression",
		},
		Parsing: "Module",
	}

	if !errors.Is(err, ErrBadRestElement) {
		t.Errorf("error could not be correctly unwrapped")
	}
}