javascript - ast_conditional_test.go

     1  package javascript
     2  
     3  import "testing"
     4  
     5  func makeConditionLiteral(tk Tokens, pos int) ConditionalExpression {
     6  	p := PrimaryExpression{
     7  		Tokens: tk[pos : pos+1],
     8  	}
     9  	if tk[pos].Type == TokenIdentifier || tk[pos].Type == TokenKeyword {
    10  		p.IdentifierReference = &tk[pos]
    11  	} else {
    12  		p.Literal = &tk[pos]
    13  	}
    14  	return *WrapConditional(&p)
    15  }
    16  
    17  func wrapConditional(i ConditionalWrappable) ConditionalExpression {
    18  	return *WrapConditional(i)
    19  }
    20  
    21  func TestConditional(t *testing.T) {
    22  	doTests(t, []sourceFn{
    23  		{`true`, func(t *test, tk Tokens) { // 1
    24  			t.Output = makeConditionLiteral(tk, 0)
    25  		}},
    26  		{`true || false`, func(t *test, tk Tokens) { // 2
    27  			litA := makeConditionLiteral(tk, 0)
    28  			litB := makeConditionLiteral(tk, 4)
    29  			t.Output = wrapConditional(LogicalORExpression{
    30  				LogicalORExpression:  litA.LogicalORExpression,
    31  				LogicalANDExpression: litB.LogicalORExpression.LogicalANDExpression,
    32  				Tokens:               tk[:5],
    33  			})
    34  		}},
    35  		{`true && false`, func(t *test, tk Tokens) { // 3
    36  			litA := makeConditionLiteral(tk, 0)
    37  			litB := makeConditionLiteral(tk, 4)
    38  			t.Output = wrapConditional(LogicalORExpression{
    39  				LogicalANDExpression: LogicalANDExpression{
    40  					LogicalANDExpression: &litA.LogicalORExpression.LogicalANDExpression,
    41  					BitwiseORExpression:  litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
    42  					Tokens:               tk[:5],
    43  				},
    44  				Tokens: tk[:5],
    45  			})
    46  		}},
    47  		{`1 || 2 || 3`, func(t *test, tk Tokens) { // 4
    48  			litA := makeConditionLiteral(tk, 0)
    49  			litB := makeConditionLiteral(tk, 4)
    50  			litC := makeConditionLiteral(tk, 8)
    51  			t.Output = wrapConditional(LogicalORExpression{
    52  				LogicalORExpression: &LogicalORExpression{
    53  					LogicalORExpression:  litA.LogicalORExpression,
    54  					LogicalANDExpression: litB.LogicalORExpression.LogicalANDExpression,
    55  					Tokens:               tk[:5],
    56  				},
    57  				LogicalANDExpression: litC.LogicalORExpression.LogicalANDExpression,
    58  				Tokens:               tk[:9],
    59  			})
    60  		}},
    61  		{`1 && 2 && 3`, func(t *test, tk Tokens) { // 5
    62  			litA := makeConditionLiteral(tk, 0)
    63  			litB := makeConditionLiteral(tk, 4)
    64  			litC := makeConditionLiteral(tk, 8)
    65  			t.Output = wrapConditional(LogicalANDExpression{
    66  				LogicalANDExpression: &LogicalANDExpression{
    67  					LogicalANDExpression: &litA.LogicalORExpression.LogicalANDExpression,
    68  					BitwiseORExpression:  litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
    69  					Tokens:               tk[:5],
    70  				},
    71  				BitwiseORExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
    72  				Tokens:              tk[:9],
    73  			})
    74  		}},
    75  		{`1 && 2 || 3`, func(t *test, tk Tokens) { // 6
    76  			litA := makeConditionLiteral(tk, 0)
    77  			litB := makeConditionLiteral(tk, 4)
    78  			litC := makeConditionLiteral(tk, 8)
    79  			t.Output = wrapConditional(LogicalORExpression{
    80  				LogicalORExpression: &LogicalORExpression{
    81  					LogicalANDExpression: LogicalANDExpression{
    82  						LogicalANDExpression: &litA.LogicalORExpression.LogicalANDExpression,
    83  						BitwiseORExpression:  litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
    84  						Tokens:               tk[:5],
    85  					},
    86  					Tokens: tk[:5],
    87  				},
    88  				LogicalANDExpression: litC.LogicalORExpression.LogicalANDExpression,
    89  				Tokens:               tk[:9],
    90  			})
    91  		}},
    92  		{`1 || 2 && 3`, func(t *test, tk Tokens) { // 7
    93  			litA := makeConditionLiteral(tk, 0)
    94  			litB := makeConditionLiteral(tk, 4)
    95  			litC := makeConditionLiteral(tk, 8)
    96  			t.Output = wrapConditional(LogicalORExpression{
    97  				LogicalORExpression: litA.LogicalORExpression,
    98  				LogicalANDExpression: LogicalANDExpression{
    99  					LogicalANDExpression: &litB.LogicalORExpression.LogicalANDExpression,
   100  					BitwiseORExpression:  litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   101  					Tokens:               tk[4:9],
   102  				},
   103  				Tokens: tk[:9],
   104  			})
   105  		}},
   106  		{`1 | 2`, func(t *test, tk Tokens) { // 8
   107  			litA := makeConditionLiteral(tk, 0)
   108  			litB := makeConditionLiteral(tk, 4)
   109  			t.Output = wrapConditional(BitwiseORExpression{
   110  				BitwiseORExpression:  &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   111  				BitwiseXORExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression,
   112  				Tokens:               tk[:5],
   113  			})
   114  		}},
   115  		{`1 | 2 | 3`, func(t *test, tk Tokens) { // 9
   116  			litA := makeConditionLiteral(tk, 0)
   117  			litB := makeConditionLiteral(tk, 4)
   118  			litC := makeConditionLiteral(tk, 8)
   119  			t.Output = wrapConditional(BitwiseORExpression{
   120  				BitwiseORExpression: &BitwiseORExpression{
   121  					BitwiseORExpression:  &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   122  					BitwiseXORExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression,
   123  					Tokens:               tk[:5],
   124  				},
   125  				BitwiseXORExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression,
   126  				Tokens:               tk[:9],
   127  			})
   128  		}},
   129  		{`1 ^ 2`, func(t *test, tk Tokens) { // 10
   130  			litA := makeConditionLiteral(tk, 0)
   131  			litB := makeConditionLiteral(tk, 4)
   132  			t.Output = wrapConditional(BitwiseXORExpression{
   133  				BitwiseXORExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression,
   134  				BitwiseANDExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression,
   135  				Tokens:               tk[:5],
   136  			})
   137  		}},
   138  		{`1 ^ 2 ^ 3`, func(t *test, tk Tokens) { // 11
   139  			litA := makeConditionLiteral(tk, 0)
   140  			litB := makeConditionLiteral(tk, 4)
   141  			litC := makeConditionLiteral(tk, 8)
   142  			t.Output = wrapConditional(BitwiseXORExpression{
   143  				BitwiseXORExpression: &BitwiseXORExpression{
   144  					BitwiseXORExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression,
   145  					BitwiseANDExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression,
   146  					Tokens:               tk[:5],
   147  				},
   148  				BitwiseANDExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression,
   149  				Tokens:               tk[:9],
   150  			})
   151  		}},
   152  		{`1 & 2`, func(t *test, tk Tokens) { // 12
   153  			litA := makeConditionLiteral(tk, 0)
   154  			litB := makeConditionLiteral(tk, 4)
   155  			t.Output = wrapConditional(BitwiseANDExpression{
   156  				BitwiseANDExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression,
   157  				EqualityExpression:   litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   158  				Tokens:               tk[:5],
   159  			})
   160  		}},
   161  		{`1 & 2 & 3`, func(t *test, tk Tokens) { // 13
   162  			litA := makeConditionLiteral(tk, 0)
   163  			litB := makeConditionLiteral(tk, 4)
   164  			litC := makeConditionLiteral(tk, 8)
   165  			t.Output = wrapConditional(BitwiseANDExpression{
   166  				BitwiseANDExpression: &BitwiseANDExpression{
   167  					BitwiseANDExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression,
   168  					EqualityExpression:   litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   169  					Tokens:               tk[:5],
   170  				},
   171  				EqualityExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   172  				Tokens:             tk[:9],
   173  			})
   174  		}},
   175  		{`1 == 2`, func(t *test, tk Tokens) { // 14
   176  			litA := makeConditionLiteral(tk, 0)
   177  			litB := makeConditionLiteral(tk, 4)
   178  			t.Output = wrapConditional(EqualityExpression{
   179  				EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   180  				EqualityOperator:     EqualityEqual,
   181  				RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   182  				Tokens:               tk[:5],
   183  			})
   184  		}},
   185  		{`1 == 2 != true`, func(t *test, tk Tokens) { // 15
   186  			litA := makeConditionLiteral(tk, 0)
   187  			litB := makeConditionLiteral(tk, 4)
   188  			litC := makeConditionLiteral(tk, 8)
   189  			t.Output = wrapConditional(EqualityExpression{
   190  				EqualityExpression: &EqualityExpression{
   191  					EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   192  					EqualityOperator:     EqualityEqual,
   193  					RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   194  					Tokens:               tk[:5],
   195  				},
   196  				EqualityOperator:     EqualityNotEqual,
   197  				RelationalExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   198  				Tokens:               tk[:9],
   199  			})
   200  		}},
   201  		{`1 != 2`, func(t *test, tk Tokens) { // 16
   202  			litA := makeConditionLiteral(tk, 0)
   203  			litB := makeConditionLiteral(tk, 4)
   204  			t.Output = wrapConditional(EqualityExpression{
   205  				EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   206  				EqualityOperator:     EqualityNotEqual,
   207  				RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   208  				Tokens:               tk[:5],
   209  			})
   210  		}},
   211  		{`1 != 2 == true`, func(t *test, tk Tokens) { // 17
   212  			litA := makeConditionLiteral(tk, 0)
   213  			litB := makeConditionLiteral(tk, 4)
   214  			litC := makeConditionLiteral(tk, 8)
   215  			t.Output = wrapConditional(EqualityExpression{
   216  				EqualityExpression: &EqualityExpression{
   217  					EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   218  					EqualityOperator:     EqualityNotEqual,
   219  					RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   220  					Tokens:               tk[:5],
   221  				},
   222  				EqualityOperator:     EqualityEqual,
   223  				RelationalExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   224  				Tokens:               tk[:9],
   225  			})
   226  		}},
   227  		{`1 === 2`, func(t *test, tk Tokens) { // 18
   228  			litA := makeConditionLiteral(tk, 0)
   229  			litB := makeConditionLiteral(tk, 4)
   230  			t.Output = wrapConditional(EqualityExpression{
   231  				EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   232  				EqualityOperator:     EqualityStrictEqual,
   233  				RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   234  				Tokens:               tk[:5],
   235  			})
   236  		}},
   237  		{`1 === 2 !== true`, func(t *test, tk Tokens) { // 19
   238  			litA := makeConditionLiteral(tk, 0)
   239  			litB := makeConditionLiteral(tk, 4)
   240  			litC := makeConditionLiteral(tk, 8)
   241  			t.Output = wrapConditional(EqualityExpression{
   242  				EqualityExpression: &EqualityExpression{
   243  					EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   244  					EqualityOperator:     EqualityStrictEqual,
   245  					RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   246  					Tokens:               tk[:5],
   247  				},
   248  				EqualityOperator:     EqualityStrictNotEqual,
   249  				RelationalExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   250  				Tokens:               tk[:9],
   251  			})
   252  		}},
   253  		{`1 !== 2`, func(t *test, tk Tokens) { // 20
   254  			litA := makeConditionLiteral(tk, 0)
   255  			litB := makeConditionLiteral(tk, 4)
   256  			t.Output = wrapConditional(EqualityExpression{
   257  				EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   258  				EqualityOperator:     EqualityStrictNotEqual,
   259  				RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   260  				Tokens:               tk[:5],
   261  			})
   262  		}},
   263  		{`1 !== 2 === true`, func(t *test, tk Tokens) { // 21
   264  			litA := makeConditionLiteral(tk, 0)
   265  			litB := makeConditionLiteral(tk, 4)
   266  			litC := makeConditionLiteral(tk, 8)
   267  			t.Output = wrapConditional(EqualityExpression{
   268  				EqualityExpression: &EqualityExpression{
   269  					EqualityExpression:   &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   270  					EqualityOperator:     EqualityStrictNotEqual,
   271  					RelationalExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   272  					Tokens:               tk[:5],
   273  				},
   274  				EqualityOperator:     EqualityStrictEqual,
   275  				RelationalExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   276  				Tokens:               tk[:9],
   277  			})
   278  		}},
   279  		{`1 < 2`, func(t *test, tk Tokens) { // 22
   280  			litA := makeConditionLiteral(tk, 0)
   281  			litB := makeConditionLiteral(tk, 4)
   282  			t.Output = wrapConditional(RelationalExpression{
   283  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   284  				RelationshipOperator: RelationshipLessThan,
   285  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   286  				Tokens:               tk[:5],
   287  			})
   288  		}},
   289  		{`1 < 2 === true`, func(t *test, tk Tokens) { // 23
   290  			litA := makeConditionLiteral(tk, 0)
   291  			litB := makeConditionLiteral(tk, 4)
   292  			litC := makeConditionLiteral(tk, 8)
   293  			t.Output = wrapConditional(EqualityExpression{
   294  				EqualityExpression: &EqualityExpression{
   295  					RelationalExpression: RelationalExpression{
   296  						RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   297  						RelationshipOperator: RelationshipLessThan,
   298  						ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   299  						Tokens:               tk[:5],
   300  					},
   301  					Tokens: tk[:5],
   302  				},
   303  				EqualityOperator:     EqualityStrictEqual,
   304  				RelationalExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   305  				Tokens:               tk[:9],
   306  			})
   307  		}},
   308  		{`true === 1 < 2`, func(t *test, tk Tokens) { // 24
   309  			litA := makeConditionLiteral(tk, 0)
   310  			litB := makeConditionLiteral(tk, 4)
   311  			litC := makeConditionLiteral(tk, 8)
   312  			t.Output = wrapConditional(EqualityExpression{
   313  				EqualityExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression,
   314  				EqualityOperator:   EqualityStrictEqual,
   315  				RelationalExpression: RelationalExpression{
   316  					RelationalExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   317  					RelationshipOperator: RelationshipLessThan,
   318  					ShiftExpression:      litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   319  					Tokens:               tk[4:9],
   320  				},
   321  				Tokens: tk[:9],
   322  			})
   323  		}},
   324  		{`1 > 2`, func(t *test, tk Tokens) { // 25
   325  			litA := makeConditionLiteral(tk, 0)
   326  			litB := makeConditionLiteral(tk, 4)
   327  			t.Output = wrapConditional(RelationalExpression{
   328  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   329  				RelationshipOperator: RelationshipGreaterThan,
   330  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   331  				Tokens:               tk[:5],
   332  			})
   333  		}},
   334  		{`1 <= 2`, func(t *test, tk Tokens) { // 26
   335  			litA := makeConditionLiteral(tk, 0)
   336  			litB := makeConditionLiteral(tk, 4)
   337  			t.Output = wrapConditional(RelationalExpression{
   338  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   339  				RelationshipOperator: RelationshipLessThanEqual,
   340  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   341  				Tokens:               tk[:5],
   342  			})
   343  		}},
   344  		{`1 >= 2`, func(t *test, tk Tokens) { // 27
   345  			litA := makeConditionLiteral(tk, 0)
   346  			litB := makeConditionLiteral(tk, 5)
   347  			t.Output = wrapConditional(RelationalExpression{
   348  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   349  				RelationshipOperator: RelationshipGreaterThanEqual,
   350  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   351  				Tokens:               tk[:6],
   352  			})
   353  		}},
   354  		{`1 instanceof 2`, func(t *test, tk Tokens) { // 28
   355  			litA := makeConditionLiteral(tk, 0)
   356  			litB := makeConditionLiteral(tk, 4)
   357  			t.Output = wrapConditional(RelationalExpression{
   358  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   359  				RelationshipOperator: RelationshipInstanceOf,
   360  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   361  				Tokens:               tk[:5],
   362  			})
   363  		}},
   364  		{`1 in 2`, func(t *test, tk Tokens) { // 29
   365  			t.Output = makeConditionLiteral(tk, 0)
   366  		}},
   367  		{`1 in 2`, func(t *test, tk Tokens) { // 30
   368  			t.In = true
   369  			litA := makeConditionLiteral(tk, 0)
   370  			litB := makeConditionLiteral(tk, 4)
   371  			t.Output = wrapConditional(RelationalExpression{
   372  				RelationalExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
   373  				RelationshipOperator: RelationshipIn,
   374  				ShiftExpression:      litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   375  				Tokens:               tk[:5],
   376  			})
   377  		}},
   378  		{`1 << 2`, func(t *test, tk Tokens) { // 31
   379  			litA := makeConditionLiteral(tk, 0)
   380  			litB := makeConditionLiteral(tk, 4)
   381  			t.Output = wrapConditional(ShiftExpression{
   382  				ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   383  				ShiftOperator:      ShiftLeft,
   384  				AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   385  				Tokens:             tk[:5],
   386  			})
   387  		}},
   388  		{`1 << 2 << 3`, func(t *test, tk Tokens) { // 32
   389  			litA := makeConditionLiteral(tk, 0)
   390  			litB := makeConditionLiteral(tk, 4)
   391  			litC := makeConditionLiteral(tk, 8)
   392  			t.Output = wrapConditional(ShiftExpression{
   393  				ShiftExpression: &ShiftExpression{
   394  					ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   395  					ShiftOperator:      ShiftLeft,
   396  					AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   397  					Tokens:             tk[:5],
   398  				},
   399  				ShiftOperator:      ShiftLeft,
   400  				AdditiveExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   401  				Tokens:             tk[:9],
   402  			})
   403  		}},
   404  		{`1 >> 2`, func(t *test, tk Tokens) { // 33
   405  			litA := makeConditionLiteral(tk, 0)
   406  			litB := makeConditionLiteral(tk, 5)
   407  			t.Output = wrapConditional(ShiftExpression{
   408  				ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   409  				ShiftOperator:      ShiftRight,
   410  				AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   411  				Tokens:             tk[:6],
   412  			})
   413  		}},
   414  		{`1 >> 2 >> 3`, func(t *test, tk Tokens) { // 34
   415  			litA := makeConditionLiteral(tk, 0)
   416  			litB := makeConditionLiteral(tk, 5)
   417  			litC := makeConditionLiteral(tk, 10)
   418  			t.Output = wrapConditional(ShiftExpression{
   419  				ShiftExpression: &ShiftExpression{
   420  					ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   421  					ShiftOperator:      ShiftRight,
   422  					AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   423  					Tokens:             tk[:6],
   424  				},
   425  				ShiftOperator:      ShiftRight,
   426  				AdditiveExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   427  				Tokens:             tk[:11],
   428  			})
   429  		}},
   430  		{`1 >>> 2`, func(t *test, tk Tokens) { // 35
   431  			litA := makeConditionLiteral(tk, 0)
   432  			litB := makeConditionLiteral(tk, 6)
   433  			t.Output = wrapConditional(ShiftExpression{
   434  				ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   435  				ShiftOperator:      ShiftUnsignedRight,
   436  				AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   437  				Tokens:             tk[:7],
   438  			})
   439  		}},
   440  		{`1 >>> 2 >>> 3`, func(t *test, tk Tokens) { // 36
   441  			litA := makeConditionLiteral(tk, 0)
   442  			litB := makeConditionLiteral(tk, 6)
   443  			litC := makeConditionLiteral(tk, 12)
   444  			t.Output = wrapConditional(ShiftExpression{
   445  				ShiftExpression: &ShiftExpression{
   446  					ShiftExpression:    &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
   447  					ShiftOperator:      ShiftUnsignedRight,
   448  					AdditiveExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   449  					Tokens:             tk[:7],
   450  				},
   451  				ShiftOperator:      ShiftUnsignedRight,
   452  				AdditiveExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   453  				Tokens:             tk[:13],
   454  			})
   455  		}},
   456  		{`1 + 2`, func(t *test, tk Tokens) { // 37
   457  			litA := makeConditionLiteral(tk, 0)
   458  			litB := makeConditionLiteral(tk, 4)
   459  			t.Output = wrapConditional(AdditiveExpression{
   460  				AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   461  				AdditiveOperator:         AdditiveAdd,
   462  				MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   463  				Tokens:                   tk[:5],
   464  			})
   465  		}},
   466  		{`1 + 2 + 3`, func(t *test, tk Tokens) { // 38
   467  			litA := makeConditionLiteral(tk, 0)
   468  			litB := makeConditionLiteral(tk, 4)
   469  			litC := makeConditionLiteral(tk, 8)
   470  			t.Output = wrapConditional(AdditiveExpression{
   471  				AdditiveExpression: &AdditiveExpression{
   472  					AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   473  					AdditiveOperator:         AdditiveAdd,
   474  					MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   475  					Tokens:                   tk[:5],
   476  				},
   477  				AdditiveOperator:         AdditiveAdd,
   478  				MultiplicativeExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   479  				Tokens:                   tk[:9],
   480  			})
   481  		}},
   482  		{`1 - 2`, func(t *test, tk Tokens) { // 39
   483  			litA := makeConditionLiteral(tk, 0)
   484  			litB := makeConditionLiteral(tk, 4)
   485  			t.Output = wrapConditional(AdditiveExpression{
   486  				AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   487  				AdditiveOperator:         AdditiveMinus,
   488  				MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   489  				Tokens:                   tk[:5],
   490  			})
   491  		}},
   492  		{`1 + 2 - 3`, func(t *test, tk Tokens) { // 40
   493  			litA := makeConditionLiteral(tk, 0)
   494  			litB := makeConditionLiteral(tk, 4)
   495  			litC := makeConditionLiteral(tk, 8)
   496  			t.Output = wrapConditional(AdditiveExpression{
   497  				AdditiveExpression: &AdditiveExpression{
   498  					AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   499  					AdditiveOperator:         AdditiveAdd,
   500  					MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   501  					Tokens:                   tk[:5],
   502  				},
   503  				AdditiveOperator:         AdditiveMinus,
   504  				MultiplicativeExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   505  				Tokens:                   tk[:9],
   506  			})
   507  		}},
   508  		{`1 - 2 - 3`, func(t *test, tk Tokens) { // 41
   509  			litA := makeConditionLiteral(tk, 0)
   510  			litB := makeConditionLiteral(tk, 4)
   511  			litC := makeConditionLiteral(tk, 8)
   512  
   513  			t.Output = wrapConditional(AdditiveExpression{
   514  				AdditiveExpression: &AdditiveExpression{
   515  					AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   516  					AdditiveOperator:         AdditiveMinus,
   517  					MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   518  					Tokens:                   tk[:5],
   519  				},
   520  				AdditiveOperator:         AdditiveMinus,
   521  				MultiplicativeExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   522  				Tokens:                   tk[:9],
   523  			})
   524  		}},
   525  		{`1 - 2 + 3`, func(t *test, tk Tokens) { // 42
   526  			litA := makeConditionLiteral(tk, 0)
   527  			litB := makeConditionLiteral(tk, 4)
   528  			litC := makeConditionLiteral(tk, 8)
   529  
   530  			t.Output = wrapConditional(AdditiveExpression{
   531  				AdditiveExpression: &AdditiveExpression{
   532  					AdditiveExpression:       &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression,
   533  					AdditiveOperator:         AdditiveMinus,
   534  					MultiplicativeExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   535  					Tokens:                   tk[:5],
   536  				},
   537  				AdditiveOperator:         AdditiveAdd,
   538  				MultiplicativeExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   539  				Tokens:                   tk[:9],
   540  			})
   541  		}},
   542  		{`1 * 2`, func(t *test, tk Tokens) { // 43
   543  			litA := makeConditionLiteral(tk, 0)
   544  			litB := makeConditionLiteral(tk, 4)
   545  			t.Output = wrapConditional(MultiplicativeExpression{
   546  				MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   547  				MultiplicativeOperator:   MultiplicativeMultiply,
   548  				ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   549  				Tokens:                   tk[:5],
   550  			})
   551  		}},
   552  		{`1 * 2 * 3`, func(t *test, tk Tokens) { // 44
   553  			litA := makeConditionLiteral(tk, 0)
   554  			litB := makeConditionLiteral(tk, 4)
   555  			litC := makeConditionLiteral(tk, 8)
   556  			t.Output = wrapConditional(MultiplicativeExpression{
   557  				MultiplicativeExpression: &MultiplicativeExpression{
   558  					MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   559  					MultiplicativeOperator:   MultiplicativeMultiply,
   560  					ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   561  					Tokens:                   tk[:5],
   562  				},
   563  				MultiplicativeOperator:   MultiplicativeMultiply,
   564  				ExponentiationExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   565  				Tokens:                   tk[:9],
   566  			})
   567  		}},
   568  		{`1 / 2`, func(t *test, tk Tokens) { // 45
   569  			litA := makeConditionLiteral(tk, 0)
   570  			litB := makeConditionLiteral(tk, 4)
   571  			t.Output = wrapConditional(MultiplicativeExpression{
   572  				MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   573  				MultiplicativeOperator:   MultiplicativeDivide,
   574  				ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   575  				Tokens:                   tk[:5],
   576  			})
   577  		}},
   578  		{`1 / 2 / 3`, func(t *test, tk Tokens) { // 46
   579  			litA := makeConditionLiteral(tk, 0)
   580  			litB := makeConditionLiteral(tk, 4)
   581  			litC := makeConditionLiteral(tk, 8)
   582  			t.Output = wrapConditional(MultiplicativeExpression{
   583  				MultiplicativeExpression: &MultiplicativeExpression{
   584  					MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   585  					MultiplicativeOperator:   MultiplicativeDivide,
   586  					ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   587  					Tokens:                   tk[:5],
   588  				},
   589  				MultiplicativeOperator:   MultiplicativeDivide,
   590  				ExponentiationExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   591  				Tokens:                   tk[:9],
   592  			})
   593  		}},
   594  		{`1 % 2`, func(t *test, tk Tokens) { // 47
   595  			litA := makeConditionLiteral(tk, 0)
   596  			litB := makeConditionLiteral(tk, 4)
   597  			t.Output = wrapConditional(MultiplicativeExpression{
   598  				MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   599  				MultiplicativeOperator:   MultiplicativeRemainder,
   600  				ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   601  				Tokens:                   tk[:5],
   602  			})
   603  		}},
   604  		{`1 % 2 % 3`, func(t *test, tk Tokens) { // 48
   605  			litA := makeConditionLiteral(tk, 0)
   606  			litB := makeConditionLiteral(tk, 4)
   607  			litC := makeConditionLiteral(tk, 8)
   608  			t.Output = wrapConditional(MultiplicativeExpression{
   609  				MultiplicativeExpression: &MultiplicativeExpression{
   610  					MultiplicativeExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression,
   611  					MultiplicativeOperator:   MultiplicativeRemainder,
   612  					ExponentiationExpression: litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   613  					Tokens:                   tk[:5],
   614  				},
   615  				MultiplicativeOperator:   MultiplicativeRemainder,
   616  				ExponentiationExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   617  				Tokens:                   tk[:9],
   618  			})
   619  		}},
   620  		{`1 ** 2`, func(t *test, tk Tokens) { // 49
   621  			litA := makeConditionLiteral(tk, 0)
   622  			litB := makeConditionLiteral(tk, 4)
   623  			t.Output = wrapConditional(ExponentiationExpression{
   624  				ExponentiationExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   625  				UnaryExpression:          litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
   626  				Tokens:                   tk[:5],
   627  			})
   628  		}},
   629  		{`1 ** 2 ** 3`, func(t *test, tk Tokens) { // 50
   630  			litA := makeConditionLiteral(tk, 0)
   631  			litB := makeConditionLiteral(tk, 4)
   632  			litC := makeConditionLiteral(tk, 8)
   633  			t.Output = wrapConditional(ExponentiationExpression{
   634  				ExponentiationExpression: &ExponentiationExpression{
   635  					ExponentiationExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression,
   636  					UnaryExpression:          litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
   637  					Tokens:                   tk[:5],
   638  				},
   639  				UnaryExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
   640  				Tokens:          tk[:9],
   641  			})
   642  		}},
   643  		{`delete 1`, func(t *test, tk Tokens) { // 51
   644  			litA := makeConditionLiteral(tk, 2)
   645  			t.Output = wrapConditional(UnaryExpression{
   646  				UnaryOperators:   []UnaryOperator{UnaryDelete},
   647  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   648  				Tokens:           tk[:3],
   649  			})
   650  		}},
   651  		{`void 1`, func(t *test, tk Tokens) { // 52
   652  			litA := makeConditionLiteral(tk, 2)
   653  			t.Output = wrapConditional(UnaryExpression{
   654  				UnaryOperators:   []UnaryOperator{UnaryVoid},
   655  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   656  				Tokens:           tk[:3],
   657  			})
   658  		}},
   659  		{`typeof 1`, func(t *test, tk Tokens) { // 53
   660  			litA := makeConditionLiteral(tk, 2)
   661  			t.Output = wrapConditional(UnaryExpression{
   662  				UnaryOperators:   []UnaryOperator{UnaryTypeOf},
   663  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   664  				Tokens:           tk[:3],
   665  			})
   666  		}},
   667  		{`+1`, func(t *test, tk Tokens) { // 54
   668  			litA := makeConditionLiteral(tk, 1)
   669  			t.Output = wrapConditional(UnaryExpression{
   670  				UnaryOperators:   []UnaryOperator{UnaryAdd},
   671  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   672  				Tokens:           tk[:2],
   673  			})
   674  		}},
   675  		{`-1`, func(t *test, tk Tokens) { // 55
   676  			litA := makeConditionLiteral(tk, 1)
   677  			t.Output = wrapConditional(UnaryExpression{
   678  				UnaryOperators:   []UnaryOperator{UnaryMinus},
   679  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   680  				Tokens:           tk[:2],
   681  			})
   682  		}},
   683  		{`~1`, func(t *test, tk Tokens) { // 56
   684  			litA := makeConditionLiteral(tk, 1)
   685  			t.Output = wrapConditional(UnaryExpression{
   686  				UnaryOperators:   []UnaryOperator{UnaryBitwiseNot},
   687  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   688  				Tokens:           tk[:2],
   689  			})
   690  		}},
   691  		{`!1`, func(t *test, tk Tokens) { // 57
   692  			litA := makeConditionLiteral(tk, 1)
   693  			t.Output = wrapConditional(UnaryExpression{
   694  				UnaryOperators:   []UnaryOperator{UnaryLogicalNot},
   695  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   696  				Tokens:           tk[:2],
   697  			})
   698  		}},
   699  		{`await 1`, func(t *test, tk Tokens) { // 58
   700  			t.Output = makeConditionLiteral(tk, 0)
   701  		}},
   702  		{`await 1`, func(t *test, tk Tokens) { // 59
   703  			t.Await = true
   704  			litA := makeConditionLiteral(tk, 2)
   705  			t.Output = wrapConditional(UnaryExpression{
   706  				UnaryOperators:   []UnaryOperator{UnaryAwait},
   707  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   708  				Tokens:           tk[:3],
   709  			})
   710  		}},
   711  		{`await!~-1`, func(t *test, tk Tokens) { // 60
   712  			t.Output = makeConditionLiteral(tk, 0)
   713  		}},
   714  		{`await!~-1`, func(t *test, tk Tokens) { // 61
   715  			t.Await = true
   716  			litA := makeConditionLiteral(tk, 4)
   717  			t.Output = wrapConditional(UnaryExpression{
   718  				UnaryOperators:   []UnaryOperator{UnaryAwait, UnaryLogicalNot, UnaryBitwiseNot, UnaryMinus},
   719  				UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   720  				Tokens:           tk[:5],
   721  			})
   722  		}},
   723  		{`a++`, func(t *test, tk Tokens) { // 62
   724  			litA := makeConditionLiteral(tk, 0)
   725  			t.Output = wrapConditional(UpdateExpression{
   726  				LeftHandSideExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
   727  				UpdateOperator:         UpdatePostIncrement,
   728  				Tokens:                 tk[:2],
   729  			})
   730  		}},
   731  		{`a--`, func(t *test, tk Tokens) { // 63
   732  			litA := makeConditionLiteral(tk, 0)
   733  			t.Output = wrapConditional(UpdateExpression{
   734  				LeftHandSideExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
   735  				UpdateOperator:         UpdatePostDecrement,
   736  				Tokens:                 tk[:2],
   737  			})
   738  		}},
   739  		{`++a`, func(t *test, tk Tokens) { // 64
   740  			litA := makeConditionLiteral(tk, 1)
   741  			t.Output = wrapConditional(UpdateExpression{
   742  				UpdateOperator:  UpdatePreIncrement,
   743  				UnaryExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
   744  				Tokens:          tk[:2],
   745  			})
   746  		}},
   747  		{`--a`, func(t *test, tk Tokens) { // 65
   748  			litA := makeConditionLiteral(tk, 1)
   749  			t.Output = wrapConditional(UpdateExpression{
   750  				UpdateOperator:  UpdatePreDecrement,
   751  				UnaryExpression: &litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
   752  				Tokens:          tk[:2],
   753  			})
   754  		}},
   755  		{`++!a`, func(t *test, tk Tokens) { // 66
   756  			litA := makeConditionLiteral(tk, 2)
   757  			t.Output = wrapConditional(UpdateExpression{
   758  				UpdateOperator: UpdatePreIncrement,
   759  				UnaryExpression: &UnaryExpression{
   760  					UnaryOperators:   []UnaryOperator{UnaryLogicalNot},
   761  					UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   762  					Tokens:           tk[1:3],
   763  				},
   764  				Tokens: tk[:3],
   765  			})
   766  		}},
   767  		{`--!a`, func(t *test, tk Tokens) { // 67
   768  			litA := makeConditionLiteral(tk, 2)
   769  			t.Output = wrapConditional(UpdateExpression{
   770  				UpdateOperator: UpdatePreDecrement,
   771  				UnaryExpression: &UnaryExpression{
   772  					UnaryOperators:   []UnaryOperator{UnaryLogicalNot},
   773  					UpdateExpression: litA.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression,
   774  					Tokens:           tk[1:3],
   775  				},
   776  				Tokens: tk[:3],
   777  			})
   778  		}},
   779  		{`true ? 1 : 2`, func(t *test, tk Tokens) { // 68
   780  			litA := makeConditionLiteral(tk, 0)
   781  			litB := makeConditionLiteral(tk, 4)
   782  			litC := makeConditionLiteral(tk, 8)
   783  			t.Output = ConditionalExpression{
   784  				LogicalORExpression: litA.LogicalORExpression,
   785  				True: &AssignmentExpression{
   786  					ConditionalExpression: &litB,
   787  					Tokens:                tk[4:5],
   788  				},
   789  				False: &AssignmentExpression{
   790  					ConditionalExpression: &litC,
   791  					Tokens:                tk[8:9],
   792  				},
   793  				Tokens: tk[:9],
   794  			}
   795  		}},
   796  		{`true ? 1 ? 2 : 3 : 4 ? 5 : 6`, func(t *test, tk Tokens) { // 69
   797  			litA := makeConditionLiteral(tk, 0)
   798  			litB := makeConditionLiteral(tk, 4)
   799  			litC := makeConditionLiteral(tk, 8)
   800  			litD := makeConditionLiteral(tk, 12)
   801  			litE := makeConditionLiteral(tk, 16)
   802  			litF := makeConditionLiteral(tk, 20)
   803  			litG := makeConditionLiteral(tk, 24)
   804  			t.Output = ConditionalExpression{
   805  				LogicalORExpression: litA.LogicalORExpression,
   806  				True: &AssignmentExpression{
   807  					ConditionalExpression: &ConditionalExpression{
   808  						LogicalORExpression: litB.LogicalORExpression,
   809  						True: &AssignmentExpression{
   810  							ConditionalExpression: &litC,
   811  							Tokens:                tk[8:9],
   812  						},
   813  						False: &AssignmentExpression{
   814  							ConditionalExpression: &litD,
   815  							Tokens:                tk[12:13],
   816  						},
   817  						Tokens: tk[4:13],
   818  					},
   819  					Tokens: tk[4:13],
   820  				},
   821  				False: &AssignmentExpression{
   822  					ConditionalExpression: &ConditionalExpression{
   823  						LogicalORExpression: litE.LogicalORExpression,
   824  						True: &AssignmentExpression{
   825  							ConditionalExpression: &litF,
   826  							Tokens:                tk[20:21],
   827  						},
   828  						False: &AssignmentExpression{
   829  							ConditionalExpression: &litG,
   830  							Tokens:                tk[24:25],
   831  						},
   832  						Tokens: tk[16:25],
   833  					},
   834  					Tokens: tk[16:25],
   835  				},
   836  				Tokens: tk[:25],
   837  			}
   838  		}},
   839  		{`true ? :`, func(t *test, tk Tokens) { // 70
   840  			t.Err = Error{
   841  				Err:     assignmentError(tk[4]),
   842  				Parsing: "ConditionalExpression",
   843  				Token:   tk[4],
   844  			}
   845  		}},
   846  		{`true ? a`, func(t *test, tk Tokens) { // 71
   847  			t.Err = Error{
   848  				Err:     ErrMissingColon,
   849  				Parsing: "ConditionalExpression",
   850  				Token:   tk[5],
   851  			}
   852  		}},
   853  		{`true ? a : :`, func(t *test, tk Tokens) { // 72
   854  			t.Err = Error{
   855  				Err:     assignmentError(tk[8]),
   856  				Parsing: "ConditionalExpression",
   857  				Token:   tk[8],
   858  			}
   859  		}},
   860  		{`++?`, func(t *test, tk Tokens) { /// 73
   861  			t.Err = Error{
   862  				Err: Error{
   863  					Err: Error{
   864  						Err: Error{
   865  							Err: Error{
   866  								Err: Error{
   867  									Err: Error{
   868  										Err: Error{
   869  											Err: Error{
   870  												Err: Error{
   871  													Err: Error{
   872  														Err: Error{
   873  															Err: Error{
   874  																Err: Error{
   875  																	Err: Error{
   876  																		Err: Error{
   877  																			Err: Error{
   878  																				Err: Error{
   879  																					Err: Error{
   880  																						Err: Error{
   881  																							Err:     ErrNoIdentifier,
   882  																							Parsing: "PrimaryExpression",
   883  																							Token:   tk[1],
   884  																						},
   885  																						Parsing: "MemberExpression",
   886  																						Token:   tk[1],
   887  																					},
   888  																					Parsing: "NewExpression",
   889  																					Token:   tk[1],
   890  																				},
   891  																				Parsing: "LeftHandSideExpression",
   892  																				Token:   tk[1],
   893  																			},
   894  																			Parsing: "UpdateExpression",
   895  																			Token:   tk[1],
   896  																		},
   897  																		Parsing: "UnaryExpression",
   898  																		Token:   tk[1],
   899  																	},
   900  																	Parsing: "UpdateExpression",
   901  																	Token:   tk[1],
   902  																},
   903  																Parsing: "UnaryExpression",
   904  																Token:   tk[0],
   905  															},
   906  															Parsing: "ExponentiationExpression",
   907  															Token:   tk[0],
   908  														},
   909  														Parsing: "MultiplicativeExpression",
   910  														Token:   tk[0],
   911  													},
   912  													Parsing: "AdditiveExpression",
   913  													Token:   tk[0],
   914  												},
   915  												Parsing: "ShiftExpression",
   916  												Token:   tk[0],
   917  											},
   918  											Parsing: "RelationalExpression",
   919  											Token:   tk[0],
   920  										},
   921  										Parsing: "EqualityExpression",
   922  										Token:   tk[0],
   923  									},
   924  									Parsing: "BitwiseANDExpression",
   925  									Token:   tk[0],
   926  								},
   927  								Parsing: "BitwiseXORExpression",
   928  								Token:   tk[0],
   929  							},
   930  							Parsing: "BitwiseORExpression",
   931  							Token:   tk[0],
   932  						},
   933  						Parsing: "LogicalANDExpression",
   934  						Token:   tk[0],
   935  					},
   936  					Parsing: "LogicalORExpression",
   937  					Token:   tk[0],
   938  				},
   939  				Parsing: "ConditionalExpression",
   940  				Token:   tk[0],
   941  			}
   942  		}},
   943  		{"a\n??\nb", func(t *test, tk Tokens) { // 74
   944  			t.Output = ConditionalExpression{
   945  				CoalesceExpression: &CoalesceExpression{
   946  					CoalesceExpressionHead: &CoalesceExpression{
   947  						BitwiseORExpression: makeConditionLiteral(tk, 0).LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   948  						Tokens:              tk[:1],
   949  					},
   950  					BitwiseORExpression: makeConditionLiteral(tk, 4).LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   951  					Tokens:              tk[:5],
   952  				},
   953  				Tokens: tk[:5],
   954  			}
   955  		}},
   956  		{"a\n??\nb\n??\nc", func(t *test, tk Tokens) { // 75
   957  			t.Output = ConditionalExpression{
   958  				CoalesceExpression: &CoalesceExpression{
   959  					CoalesceExpressionHead: &CoalesceExpression{
   960  						CoalesceExpressionHead: &CoalesceExpression{
   961  							BitwiseORExpression: makeConditionLiteral(tk, 0).LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   962  							Tokens:              tk[:1],
   963  						},
   964  						BitwiseORExpression: makeConditionLiteral(tk, 4).LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   965  						Tokens:              tk[:5],
   966  					},
   967  					BitwiseORExpression: makeConditionLiteral(tk, 8).LogicalORExpression.LogicalANDExpression.BitwiseORExpression,
   968  					Tokens:              tk[:9],
   969  				},
   970  				Tokens: tk[:9],
   971  			}
   972  		}},
   973  		{"a\n??\n!", func(t *test, tk Tokens) { // 76
   974  			t.Err = Error{
   975  				Err: Error{
   976  					Err: Error{
   977  						Err: Error{
   978  							Err: Error{
   979  								Err: Error{
   980  									Err: Error{
   981  										Err: Error{
   982  											Err: Error{
   983  												Err: Error{
   984  													Err: Error{
   985  														Err: Error{
   986  															Err: Error{
   987  																Err: Error{
   988  																	Err: Error{
   989  																		Err: Error{
   990  																			Err: Error{
   991  																				Err:     ErrNoIdentifier,
   992  																				Parsing: "PrimaryExpression",
   993  																				Token:   tk[5],
   994  																			},
   995  																			Parsing: "MemberExpression",
   996  																			Token:   tk[5],
   997  																		},
   998  																		Parsing: "NewExpression",
   999  																		Token:   tk[5],
  1000  																	},
  1001  																	Parsing: "LeftHandSideExpression",
  1002  																	Token:   tk[5],
  1003  																},
  1004  																Parsing: "UpdateExpression",
  1005  																Token:   tk[5],
  1006  															},
  1007  															Parsing: "UnaryExpression",
  1008  															Token:   tk[5],
  1009  														},
  1010  														Parsing: "ExponentiationExpression",
  1011  														Token:   tk[4],
  1012  													},
  1013  													Parsing: "MultiplicativeExpression",
  1014  													Token:   tk[4],
  1015  												},
  1016  												Parsing: "AdditiveExpression",
  1017  												Token:   tk[4],
  1018  											},
  1019  											Parsing: "ShiftExpression",
  1020  											Token:   tk[4],
  1021  										},
  1022  										Parsing: "RelationalExpression",
  1023  										Token:   tk[4],
  1024  									},
  1025  									Parsing: "EqualityExpression",
  1026  									Token:   tk[4],
  1027  								},
  1028  								Parsing: "BitwiseANDExpression",
  1029  								Token:   tk[4],
  1030  							},
  1031  							Parsing: "BitwiseXORExpression",
  1032  							Token:   tk[4],
  1033  						},
  1034  						Parsing: "BitwiseORExpression",
  1035  						Token:   tk[4],
  1036  					},
  1037  					Parsing: "CoalesceExpression",
  1038  					Token:   tk[4],
  1039  				},
  1040  				Parsing: "ConditionalExpression",
  1041  				Token:   tk[1],
  1042  			}
  1043  		}},
  1044  		{"1++", func(t *test, tk Tokens) { // 77
  1045  			t.Err = Error{
  1046  				Err: Error{
  1047  					Err: Error{
  1048  						Err: Error{
  1049  							Err: Error{
  1050  								Err: Error{
  1051  									Err: Error{
  1052  										Err: Error{
  1053  											Err: Error{
  1054  												Err: Error{
  1055  													Err: Error{
  1056  														Err: Error{
  1057  															Err: Error{
  1058  																Err: Error{
  1059  																	Err:     ErrNotSimple,
  1060  																	Parsing: "UpdateExpression",
  1061  																	Token:   tk[1],
  1062  																},
  1063  																Parsing: "UnaryExpression",
  1064  																Token:   tk[0],
  1065  															},
  1066  															Parsing: "ExponentiationExpression",
  1067  															Token:   tk[0],
  1068  														},
  1069  														Parsing: "MultiplicativeExpression",
  1070  														Token:   tk[0],
  1071  													},
  1072  													Parsing: "AdditiveExpression",
  1073  													Token:   tk[0],
  1074  												},
  1075  												Parsing: "ShiftExpression",
  1076  												Token:   tk[0],
  1077  											},
  1078  											Parsing: "RelationalExpression",
  1079  											Token:   tk[0],
  1080  										},
  1081  										Parsing: "EqualityExpression",
  1082  										Token:   tk[0],
  1083  									},
  1084  									Parsing: "BitwiseANDExpression",
  1085  									Token:   tk[0],
  1086  								},
  1087  								Parsing: "BitwiseXORExpression",
  1088  								Token:   tk[0],
  1089  							},
  1090  							Parsing: "BitwiseORExpression",
  1091  							Token:   tk[0],
  1092  						},
  1093  						Parsing: "LogicalANDExpression",
  1094  						Token:   tk[0],
  1095  					},
  1096  					Parsing: "LogicalORExpression",
  1097  					Token:   tk[0],
  1098  				},
  1099  				Parsing: "ConditionalExpression",
  1100  				Token:   tk[0],
  1101  			}
  1102  		}},
  1103  		{"1--", func(t *test, tk Tokens) { // 78
  1104  			t.Err = Error{
  1105  				Err: Error{
  1106  					Err: Error{
  1107  						Err: Error{
  1108  							Err: Error{
  1109  								Err: Error{
  1110  									Err: Error{
  1111  										Err: Error{
  1112  											Err: Error{
  1113  												Err: Error{
  1114  													Err: Error{
  1115  														Err: Error{
  1116  															Err: Error{
  1117  																Err: Error{
  1118  																	Err:     ErrNotSimple,
  1119  																	Parsing: "UpdateExpression",
  1120  																	Token:   tk[1],
  1121  																},
  1122  																Parsing: "UnaryExpression",
  1123  																Token:   tk[0],
  1124  															},
  1125  															Parsing: "ExponentiationExpression",
  1126  															Token:   tk[0],
  1127  														},
  1128  														Parsing: "MultiplicativeExpression",
  1129  														Token:   tk[0],
  1130  													},
  1131  													Parsing: "AdditiveExpression",
  1132  													Token:   tk[0],
  1133  												},
  1134  												Parsing: "ShiftExpression",
  1135  												Token:   tk[0],
  1136  											},
  1137  											Parsing: "RelationalExpression",
  1138  											Token:   tk[0],
  1139  										},
  1140  										Parsing: "EqualityExpression",
  1141  										Token:   tk[0],
  1142  									},
  1143  									Parsing: "BitwiseANDExpression",
  1144  									Token:   tk[0],
  1145  								},
  1146  								Parsing: "BitwiseXORExpression",
  1147  								Token:   tk[0],
  1148  							},
  1149  							Parsing: "BitwiseORExpression",
  1150  							Token:   tk[0],
  1151  						},
  1152  						Parsing: "LogicalANDExpression",
  1153  						Token:   tk[0],
  1154  					},
  1155  					Parsing: "LogicalORExpression",
  1156  					Token:   tk[0],
  1157  				},
  1158  				Parsing: "ConditionalExpression",
  1159  				Token:   tk[0],
  1160  			}
  1161  		}},
  1162  		{"#a in b", func(t *test, tk Tokens) { // 79
  1163  			t.In = true
  1164  			t.Output = *WrapConditional(RelationalExpression{
  1165  				PrivateIdentifier:    &tk[0],
  1166  				RelationshipOperator: RelationshipIn,
  1167  				ShiftExpression: ShiftExpression{
  1168  					AdditiveExpression: AdditiveExpression{
  1169  						MultiplicativeExpression: MultiplicativeExpression{
  1170  							ExponentiationExpression: ExponentiationExpression{
  1171  								UnaryExpression: UnaryExpression{
  1172  									UpdateExpression: UpdateExpression{
  1173  										LeftHandSideExpression: &LeftHandSideExpression{
  1174  											NewExpression: &NewExpression{
  1175  												MemberExpression: MemberExpression{
  1176  													PrimaryExpression: &PrimaryExpression{
  1177  														IdentifierReference: &tk[4],
  1178  														Tokens:              tk[4:5],
  1179  													},
  1180  													Tokens: tk[4:5],
  1181  												},
  1182  												Tokens: tk[4:5],
  1183  											},
  1184  											Tokens: tk[4:5],
  1185  										},
  1186  										Tokens: tk[4:5],
  1187  									},
  1188  									Tokens: tk[4:5],
  1189  								},
  1190  								Tokens: tk[4:5],
  1191  							},
  1192  							Tokens: tk[4:5],
  1193  						},
  1194  						Tokens: tk[4:5],
  1195  					},
  1196  					Tokens: tk[4:5],
  1197  				},
  1198  				Tokens: tk[:5],
  1199  			})
  1200  		}},
  1201  		{"#a in b", func(t *test, tk Tokens) { // 80
  1202  			t.Err = Error{
  1203  				Err: Error{
  1204  					Err: Error{
  1205  						Err: Error{
  1206  							Err: Error{
  1207  								Err: Error{
  1208  									Err: Error{
  1209  										Err: Error{
  1210  											Err: Error{
  1211  												Err: Error{
  1212  													Err: Error{
  1213  														Err: Error{
  1214  															Err: Error{
  1215  																Err: Error{
  1216  																	Err: Error{
  1217  																		Err: Error{
  1218  																			Err: Error{
  1219  																				Err: Error{
  1220  																					Err:     ErrNoIdentifier,
  1221  																					Parsing: "PrimaryExpression",
  1222  																					Token:   tk[0],
  1223  																				},
  1224  																				Parsing: "MemberExpression",
  1225  																				Token:   tk[0],
  1226  																			},
  1227  																			Parsing: "NewExpression",
  1228  																			Token:   tk[0],
  1229  																		},
  1230  																		Parsing: "LeftHandSideExpression",
  1231  																		Token:   tk[0],
  1232  																	},
  1233  																	Parsing: "UpdateExpression",
  1234  																	Token:   tk[0],
  1235  																},
  1236  																Parsing: "UnaryExpression",
  1237  																Token:   tk[0],
  1238  															},
  1239  															Parsing: "ExponentiationExpression",
  1240  															Token:   tk[0],
  1241  														},
  1242  														Parsing: "MultiplicativeExpression",
  1243  														Token:   tk[0],
  1244  													},
  1245  													Parsing: "AdditiveExpression",
  1246  													Token:   tk[0],
  1247  												},
  1248  												Parsing: "ShiftExpression",
  1249  												Token:   tk[0],
  1250  											},
  1251  											Parsing: "RelationalExpression",
  1252  											Token:   tk[0],
  1253  										},
  1254  										Parsing: "EqualityExpression",
  1255  										Token:   tk[0],
  1256  									},
  1257  									Parsing: "BitwiseANDExpression",
  1258  									Token:   tk[0],
  1259  								},
  1260  								Parsing: "BitwiseXORExpression",
  1261  								Token:   tk[0],
  1262  							},
  1263  							Parsing: "BitwiseORExpression",
  1264  							Token:   tk[0],
  1265  						},
  1266  						Parsing: "LogicalANDExpression",
  1267  						Token:   tk[0],
  1268  					},
  1269  					Parsing: "LogicalORExpression",
  1270  					Token:   tk[0],
  1271  				},
  1272  				Parsing: "ConditionalExpression",
  1273  				Token:   tk[0],
  1274  			}
  1275  		}},
  1276  		{"#a of b", func(t *test, tk Tokens) { // 81
  1277  			t.In = true
  1278  			t.Err = Error{
  1279  				Err: Error{
  1280  					Err: Error{
  1281  						Err: Error{
  1282  							Err: Error{
  1283  								Err: Error{
  1284  									Err: Error{
  1285  										Err: Error{
  1286  											Err: Error{
  1287  												Err: Error{
  1288  													Err: Error{
  1289  														Err: Error{
  1290  															Err: Error{
  1291  																Err: Error{
  1292  																	Err: Error{
  1293  																		Err: Error{
  1294  																			Err: Error{
  1295  																				Err: Error{
  1296  																					Err:     ErrNoIdentifier,
  1297  																					Parsing: "PrimaryExpression",
  1298  																					Token:   tk[0],
  1299  																				},
  1300  																				Parsing: "MemberExpression",
  1301  																				Token:   tk[0],
  1302  																			},
  1303  																			Parsing: "NewExpression",
  1304  																			Token:   tk[0],
  1305  																		},
  1306  																		Parsing: "LeftHandSideExpression",
  1307  																		Token:   tk[0],
  1308  																	},
  1309  																	Parsing: "UpdateExpression",
  1310  																	Token:   tk[0],
  1311  																},
  1312  																Parsing: "UnaryExpression",
  1313  																Token:   tk[0],
  1314  															},
  1315  															Parsing: "ExponentiationExpression",
  1316  															Token:   tk[0],
  1317  														},
  1318  														Parsing: "MultiplicativeExpression",
  1319  														Token:   tk[0],
  1320  													},
  1321  													Parsing: "AdditiveExpression",
  1322  													Token:   tk[0],
  1323  												},
  1324  												Parsing: "ShiftExpression",
  1325  												Token:   tk[0],
  1326  											},
  1327  											Parsing: "RelationalExpression",
  1328  											Token:   tk[0],
  1329  										},
  1330  										Parsing: "EqualityExpression",
  1331  										Token:   tk[0],
  1332  									},
  1333  									Parsing: "BitwiseANDExpression",
  1334  									Token:   tk[0],
  1335  								},
  1336  								Parsing: "BitwiseXORExpression",
  1337  								Token:   tk[0],
  1338  							},
  1339  							Parsing: "BitwiseORExpression",
  1340  							Token:   tk[0],
  1341  						},
  1342  						Parsing: "LogicalANDExpression",
  1343  						Token:   tk[0],
  1344  					},
  1345  					Parsing: "LogicalORExpression",
  1346  					Token:   tk[0],
  1347  				},
  1348  				Parsing: "ConditionalExpression",
  1349  				Token:   tk[0],
  1350  			}
  1351  		}},
  1352  		{"#a in #b", func(t *test, tk Tokens) { // 82
  1353  			t.In = true
  1354  			t.Err = Error{
  1355  				Err: Error{
  1356  					Err: Error{
  1357  						Err: Error{
  1358  							Err: Error{
  1359  								Err: Error{
  1360  									Err: Error{
  1361  										Err: Error{
  1362  											Err: Error{
  1363  												Err: Error{
  1364  													Err: Error{
  1365  														Err: Error{
  1366  															Err: Error{
  1367  																Err: Error{
  1368  																	Err: Error{
  1369  																		Err: Error{
  1370  																			Err: Error{
  1371  																				Err: Error{
  1372  																					Err:     ErrNoIdentifier,
  1373  																					Parsing: "PrimaryExpression",
  1374  																					Token:   tk[4],
  1375  																				},
  1376  																				Parsing: "MemberExpression",
  1377  																				Token:   tk[4],
  1378  																			},
  1379  																			Parsing: "NewExpression",
  1380  																			Token:   tk[4],
  1381  																		},
  1382  																		Parsing: "LeftHandSideExpression",
  1383  																		Token:   tk[4],
  1384  																	},
  1385  																	Parsing: "UpdateExpression",
  1386  																	Token:   tk[4],
  1387  																},
  1388  																Parsing: "UnaryExpression",
  1389  																Token:   tk[4],
  1390  															},
  1391  															Parsing: "ExponentiationExpression",
  1392  															Token:   tk[4],
  1393  														},
  1394  														Parsing: "MultiplicativeExpression",
  1395  														Token:   tk[4],
  1396  													},
  1397  													Parsing: "AdditiveExpression",
  1398  													Token:   tk[4],
  1399  												},
  1400  												Parsing: "ShiftExpression",
  1401  												Token:   tk[4],
  1402  											},
  1403  											Parsing: "RelationalExpression",
  1404  											Token:   tk[0],
  1405  										},
  1406  										Parsing: "EqualityExpression",
  1407  										Token:   tk[0],
  1408  									},
  1409  									Parsing: "BitwiseANDExpression",
  1410  									Token:   tk[0],
  1411  								},
  1412  								Parsing: "BitwiseXORExpression",
  1413  								Token:   tk[0],
  1414  							},
  1415  							Parsing: "BitwiseORExpression",
  1416  							Token:   tk[0],
  1417  						},
  1418  						Parsing: "LogicalANDExpression",
  1419  						Token:   tk[0],
  1420  					},
  1421  					Parsing: "LogicalORExpression",
  1422  					Token:   tk[0],
  1423  				},
  1424  				Parsing: "ConditionalExpression",
  1425  				Token:   tk[0],
  1426  			}
  1427  		}},
  1428  		{"this.#a", func(t *test, tk Tokens) { // 83
  1429  			t.Output = *WrapConditional(MemberExpression{
  1430  				MemberExpression: &MemberExpression{
  1431  					PrimaryExpression: &PrimaryExpression{
  1432  						This:   &tk[0],
  1433  						Tokens: tk[:1],
  1434  					},
  1435  					Tokens: tk[:1],
  1436  				},
  1437  				PrivateIdentifier: &tk[2],
  1438  				Tokens:            tk[:3],
  1439  			})
  1440  		}},
  1441  		{"this.#a++", func(t *test, tk Tokens) { // 84
  1442  			t.Output = *WrapConditional(UpdateExpression{
  1443  				LeftHandSideExpression: &LeftHandSideExpression{
  1444  					NewExpression: &NewExpression{
  1445  						MemberExpression: MemberExpression{
  1446  							MemberExpression: &MemberExpression{
  1447  								PrimaryExpression: &PrimaryExpression{
  1448  									This:   &tk[0],
  1449  									Tokens: tk[:1],
  1450  								},
  1451  								Tokens: tk[:1],
  1452  							},
  1453  							PrivateIdentifier: &tk[2],
  1454  							Tokens:            tk[:3],
  1455  						},
  1456  						Tokens: tk[:3],
  1457  					},
  1458  					Tokens: tk[:3],
  1459  				},
  1460  				UpdateOperator: UpdatePostIncrement,
  1461  				Tokens:         tk[:4],
  1462  			})
  1463  		}},
  1464  	}, func(t *test) (Type, error) {
  1465  		var ce ConditionalExpression
  1466  		err := ce.parse(&t.Tokens, t.In, t.Yield, t.Await)
  1467  		return ce, err
  1468  	})
  1469  }
  1470