javascript - walk.go

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