python - walk.go

     1  // Package walk provides a python type walker.
     2  package walk
     3  
     4  import "vimagination.zapto.org/python"
     5  
     6  // Handler is used to process python types.
     7  type Handler interface {
     8  	Handle(python.Type) error
     9  }
    10  
    11  // HandlerFunc wraps a func to implement Handler interface.
    12  type HandlerFunc func(python.Type) error
    13  
    14  // Handle implements the Handler interface.
    15  func (h HandlerFunc) Handle(t python.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 R type.
    20  func Walk(t python.Type, fn Handler) error {
    21  	switch t := t.(type) {
    22  	case python.AddExpression:
    23  		return walkAddExpression(&t, fn)
    24  	case *python.AddExpression:
    25  		return walkAddExpression(t, fn)
    26  	case python.AndExpression:
    27  		return walkAndExpression(&t, fn)
    28  	case *python.AndExpression:
    29  		return walkAndExpression(t, fn)
    30  	case python.AndTest:
    31  		return walkAndTest(&t, fn)
    32  	case *python.AndTest:
    33  		return walkAndTest(t, fn)
    34  	case python.AnnotatedAssignmentStatement:
    35  		return walkAnnotatedAssignmentStatement(&t, fn)
    36  	case *python.AnnotatedAssignmentStatement:
    37  		return walkAnnotatedAssignmentStatement(t, fn)
    38  	case python.ArgumentList:
    39  		return walkArgumentList(&t, fn)
    40  	case *python.ArgumentList:
    41  		return walkArgumentList(t, fn)
    42  	case python.ArgumentListOrComprehension:
    43  		return walkArgumentListOrComprehension(&t, fn)
    44  	case *python.ArgumentListOrComprehension:
    45  		return walkArgumentListOrComprehension(t, fn)
    46  	case python.AssertStatement:
    47  		return walkAssertStatement(&t, fn)
    48  	case *python.AssertStatement:
    49  		return walkAssertStatement(t, fn)
    50  	case python.AssignmentExpressionAndSuite:
    51  		return walkAssignmentExpressionAndSuite(&t, fn)
    52  	case *python.AssignmentExpressionAndSuite:
    53  		return walkAssignmentExpressionAndSuite(t, fn)
    54  	case python.AssignmentExpression:
    55  		return walkAssignmentExpression(&t, fn)
    56  	case *python.AssignmentExpression:
    57  		return walkAssignmentExpression(t, fn)
    58  	case python.AssignmentStatement:
    59  		return walkAssignmentStatement(&t, fn)
    60  	case *python.AssignmentStatement:
    61  		return walkAssignmentStatement(t, fn)
    62  	case python.Atom:
    63  		return walkAtom(&t, fn)
    64  	case *python.Atom:
    65  		return walkAtom(t, fn)
    66  	case python.AugmentedAssignmentStatement:
    67  		return walkAugmentedAssignmentStatement(&t, fn)
    68  	case *python.AugmentedAssignmentStatement:
    69  		return walkAugmentedAssignmentStatement(t, fn)
    70  	case python.AugTarget:
    71  		return walkAugTarget(&t, fn)
    72  	case *python.AugTarget:
    73  		return walkAugTarget(t, fn)
    74  	case python.ClassDefinition:
    75  		return walkClassDefinition(&t, fn)
    76  	case *python.ClassDefinition:
    77  		return walkClassDefinition(t, fn)
    78  	case python.Comparison:
    79  		return walkComparison(&t, fn)
    80  	case *python.Comparison:
    81  		return walkComparison(t, fn)
    82  	case python.ComparisonExpression:
    83  		return walkComparisonExpression(&t, fn)
    84  	case *python.ComparisonExpression:
    85  		return walkComparisonExpression(t, fn)
    86  	case python.CompoundStatement:
    87  		return walkCompoundStatement(&t, fn)
    88  	case *python.CompoundStatement:
    89  		return walkCompoundStatement(t, fn)
    90  	case python.Comprehension:
    91  		return walkComprehension(&t, fn)
    92  	case *python.Comprehension:
    93  		return walkComprehension(t, fn)
    94  	case python.ComprehensionFor:
    95  		return walkComprehensionFor(&t, fn)
    96  	case *python.ComprehensionFor:
    97  		return walkComprehensionFor(t, fn)
    98  	case python.ComprehensionIf:
    99  		return walkComprehensionIf(&t, fn)
   100  	case *python.ComprehensionIf:
   101  		return walkComprehensionIf(t, fn)
   102  	case python.ComprehensionIterator:
   103  		return walkComprehensionIterator(&t, fn)
   104  	case *python.ComprehensionIterator:
   105  		return walkComprehensionIterator(t, fn)
   106  	case python.ConditionalExpression:
   107  		return walkConditionalExpression(&t, fn)
   108  	case *python.ConditionalExpression:
   109  		return walkConditionalExpression(t, fn)
   110  	case python.Decorators:
   111  		return walkDecorators(&t, fn)
   112  	case *python.Decorators:
   113  		return walkDecorators(t, fn)
   114  	case python.DefParameter:
   115  		return walkDefParameter(&t, fn)
   116  	case *python.DefParameter:
   117  		return walkDefParameter(t, fn)
   118  	case python.DelStatement:
   119  		return walkDelStatement(&t, fn)
   120  	case *python.DelStatement:
   121  		return walkDelStatement(t, fn)
   122  	case python.DictDisplay:
   123  		return walkDictDisplay(&t, fn)
   124  	case *python.DictDisplay:
   125  		return walkDictDisplay(t, fn)
   126  	case python.DictItem:
   127  		return walkDictItem(&t, fn)
   128  	case *python.DictItem:
   129  		return walkDictItem(t, fn)
   130  	case python.Enclosure:
   131  		return walkEnclosure(&t, fn)
   132  	case *python.Enclosure:
   133  		return walkEnclosure(t, fn)
   134  	case python.Except:
   135  		return walkExcept(&t, fn)
   136  	case *python.Except:
   137  		return walkExcept(t, fn)
   138  	case python.Expression:
   139  		return walkExpression(&t, fn)
   140  	case *python.Expression:
   141  		return walkExpression(t, fn)
   142  	case python.ExpressionList:
   143  		return walkExpressionList(&t, fn)
   144  	case *python.ExpressionList:
   145  		return walkExpressionList(t, fn)
   146  	case python.File:
   147  		return walkFile(&t, fn)
   148  	case *python.File:
   149  		return walkFile(t, fn)
   150  	case python.FlexibleExpression:
   151  		return walkFlexibleExpression(&t, fn)
   152  	case *python.FlexibleExpression:
   153  		return walkFlexibleExpression(t, fn)
   154  	case python.FlexibleExpressionList:
   155  		return walkFlexibleExpressionList(&t, fn)
   156  	case *python.FlexibleExpressionList:
   157  		return walkFlexibleExpressionList(t, fn)
   158  	case python.FlexibleExpressionListOrComprehension:
   159  		return walkFlexibleExpressionListOrComprehension(&t, fn)
   160  	case *python.FlexibleExpressionListOrComprehension:
   161  		return walkFlexibleExpressionListOrComprehension(t, fn)
   162  	case python.ForStatement:
   163  		return walkForStatement(&t, fn)
   164  	case *python.ForStatement:
   165  		return walkForStatement(t, fn)
   166  	case python.FuncDefinition:
   167  		return walkFuncDefinition(&t, fn)
   168  	case *python.FuncDefinition:
   169  		return walkFuncDefinition(t, fn)
   170  	case python.GeneratorExpression:
   171  		return walkGeneratorExpression(&t, fn)
   172  	case *python.GeneratorExpression:
   173  		return walkGeneratorExpression(t, fn)
   174  	case python.GlobalStatement:
   175  		return walkGlobalStatement(&t, fn)
   176  	case *python.GlobalStatement:
   177  		return walkGlobalStatement(t, fn)
   178  	case python.IfStatement:
   179  		return walkIfStatement(&t, fn)
   180  	case *python.IfStatement:
   181  		return walkIfStatement(t, fn)
   182  	case python.ImportStatement:
   183  		return walkImportStatement(&t, fn)
   184  	case *python.ImportStatement:
   185  		return walkImportStatement(t, fn)
   186  	case python.KeywordArgument:
   187  		return walkKeywordArgument(&t, fn)
   188  	case *python.KeywordArgument:
   189  		return walkKeywordArgument(t, fn)
   190  	case python.KeywordItem:
   191  		return walkKeywordItem(&t, fn)
   192  	case *python.KeywordItem:
   193  		return walkKeywordItem(t, fn)
   194  	case python.LambdaExpression:
   195  		return walkLambdaExpression(&t, fn)
   196  	case *python.LambdaExpression:
   197  		return walkLambdaExpression(t, fn)
   198  	case python.ModuleAs:
   199  		return walkModuleAs(&t, fn)
   200  	case *python.ModuleAs:
   201  		return walkModuleAs(t, fn)
   202  	case python.Module:
   203  		return walkModule(&t, fn)
   204  	case *python.Module:
   205  		return walkModule(t, fn)
   206  	case python.MultiplyExpression:
   207  		return walkMultiplyExpression(&t, fn)
   208  	case *python.MultiplyExpression:
   209  		return walkMultiplyExpression(t, fn)
   210  	case python.NonLocalStatement:
   211  		return walkNonLocalStatement(&t, fn)
   212  	case *python.NonLocalStatement:
   213  		return walkNonLocalStatement(t, fn)
   214  	case python.NotTest:
   215  		return walkNotTest(&t, fn)
   216  	case *python.NotTest:
   217  		return walkNotTest(t, fn)
   218  	case python.OrExpression:
   219  		return walkOrExpression(&t, fn)
   220  	case *python.OrExpression:
   221  		return walkOrExpression(t, fn)
   222  	case python.OrTest:
   223  		return walkOrTest(&t, fn)
   224  	case *python.OrTest:
   225  		return walkOrTest(t, fn)
   226  	case python.Parameter:
   227  		return walkParameter(&t, fn)
   228  	case *python.Parameter:
   229  		return walkParameter(t, fn)
   230  	case python.ParameterList:
   231  		return walkParameterList(&t, fn)
   232  	case *python.ParameterList:
   233  		return walkParameterList(t, fn)
   234  	case python.PositionalArgument:
   235  		return walkPositionalArgument(&t, fn)
   236  	case *python.PositionalArgument:
   237  		return walkPositionalArgument(t, fn)
   238  	case python.PowerExpression:
   239  		return walkPowerExpression(&t, fn)
   240  	case *python.PowerExpression:
   241  		return walkPowerExpression(t, fn)
   242  	case python.PrimaryExpression:
   243  		return walkPrimaryExpression(&t, fn)
   244  	case *python.PrimaryExpression:
   245  		return walkPrimaryExpression(t, fn)
   246  	case python.RaiseStatement:
   247  		return walkRaiseStatement(&t, fn)
   248  	case *python.RaiseStatement:
   249  		return walkRaiseStatement(t, fn)
   250  	case python.RelativeModule:
   251  		return walkRelativeModule(&t, fn)
   252  	case *python.RelativeModule:
   253  		return walkRelativeModule(t, fn)
   254  	case python.ReturnStatement:
   255  		return walkReturnStatement(&t, fn)
   256  	case *python.ReturnStatement:
   257  		return walkReturnStatement(t, fn)
   258  	case python.ShiftExpression:
   259  		return walkShiftExpression(&t, fn)
   260  	case *python.ShiftExpression:
   261  		return walkShiftExpression(t, fn)
   262  	case python.SimpleStatement:
   263  		return walkSimpleStatement(&t, fn)
   264  	case *python.SimpleStatement:
   265  		return walkSimpleStatement(t, fn)
   266  	case python.SliceItem:
   267  		return walkSliceItem(&t, fn)
   268  	case *python.SliceItem:
   269  		return walkSliceItem(t, fn)
   270  	case python.SliceList:
   271  		return walkSliceList(&t, fn)
   272  	case *python.SliceList:
   273  		return walkSliceList(t, fn)
   274  	case python.StarredExpression:
   275  		return walkStarredExpression(&t, fn)
   276  	case *python.StarredExpression:
   277  		return walkStarredExpression(t, fn)
   278  	case python.StarredItem:
   279  		return walkStarredItem(&t, fn)
   280  	case *python.StarredItem:
   281  		return walkStarredItem(t, fn)
   282  	case python.StarredList:
   283  		return walkStarredList(&t, fn)
   284  	case *python.StarredList:
   285  		return walkStarredList(t, fn)
   286  	case python.StarredOrKeyword:
   287  		return walkStarredOrKeyword(&t, fn)
   288  	case *python.StarredOrKeyword:
   289  		return walkStarredOrKeyword(t, fn)
   290  	case python.Statement:
   291  		return walkStatement(&t, fn)
   292  	case *python.Statement:
   293  		return walkStatement(t, fn)
   294  	case python.StatementList:
   295  		return walkStatementList(&t, fn)
   296  	case *python.StatementList:
   297  		return walkStatementList(t, fn)
   298  	case python.Suite:
   299  		return walkSuite(&t, fn)
   300  	case *python.Suite:
   301  		return walkSuite(t, fn)
   302  	case python.Target:
   303  		return walkTarget(&t, fn)
   304  	case *python.Target:
   305  		return walkTarget(t, fn)
   306  	case python.TargetList:
   307  		return walkTargetList(&t, fn)
   308  	case *python.TargetList:
   309  		return walkTargetList(t, fn)
   310  	case python.TryStatement:
   311  		return walkTryStatement(&t, fn)
   312  	case *python.TryStatement:
   313  		return walkTryStatement(t, fn)
   314  	case python.TypeParam:
   315  		return walkTypeParam(&t, fn)
   316  	case *python.TypeParam:
   317  		return walkTypeParam(t, fn)
   318  	case python.TypeParams:
   319  		return walkTypeParams(&t, fn)
   320  	case *python.TypeParams:
   321  		return walkTypeParams(t, fn)
   322  	case python.TypeStatement:
   323  		return walkTypeStatement(&t, fn)
   324  	case *python.TypeStatement:
   325  		return walkTypeStatement(t, fn)
   326  	case python.UnaryExpression:
   327  		return walkUnaryExpression(&t, fn)
   328  	case *python.UnaryExpression:
   329  		return walkUnaryExpression(t, fn)
   330  	case python.WhileStatement:
   331  		return walkWhileStatement(&t, fn)
   332  	case *python.WhileStatement:
   333  		return walkWhileStatement(t, fn)
   334  	case python.WithItem:
   335  		return walkWithItem(&t, fn)
   336  	case *python.WithItem:
   337  		return walkWithItem(t, fn)
   338  	case python.WithStatement:
   339  		return walkWithStatement(&t, fn)
   340  	case *python.WithStatement:
   341  		return walkWithStatement(t, fn)
   342  	case python.WithStatementContents:
   343  		return walkWithStatementContents(&t, fn)
   344  	case *python.WithStatementContents:
   345  		return walkWithStatementContents(t, fn)
   346  	case python.XorExpression:
   347  		return walkXorExpression(&t, fn)
   348  	case *python.XorExpression:
   349  		return walkXorExpression(t, fn)
   350  	case python.YieldExpression:
   351  		return walkYieldExpression(&t, fn)
   352  	case *python.YieldExpression:
   353  		return walkYieldExpression(t, fn)
   354  	}
   355  
   356  	return nil
   357  }
   358  
   359  func walkAddExpression(t *python.AddExpression, fn Handler) error {
   360  	if err := fn.Handle(&t.MultiplyExpression); err != nil {
   361  		return err
   362  	}
   363  
   364  	if t.AddExpression != nil {
   365  		return fn.Handle(t.AddExpression)
   366  	}
   367  
   368  	return nil
   369  }
   370  
   371  func walkAndExpression(t *python.AndExpression, fn Handler) error {
   372  	if err := fn.Handle(&t.ShiftExpression); err != nil {
   373  		return err
   374  	}
   375  
   376  	if t.AndExpression != nil {
   377  		return fn.Handle(t.AndExpression)
   378  	}
   379  
   380  	return nil
   381  }
   382  
   383  func walkAndTest(t *python.AndTest, fn Handler) error {
   384  	if err := fn.Handle(&t.NotTest); err != nil {
   385  		return err
   386  	}
   387  
   388  	if t.AndTest != nil {
   389  		return fn.Handle(t.AndTest)
   390  	}
   391  
   392  	return nil
   393  }
   394  
   395  func walkAnnotatedAssignmentStatement(t *python.AnnotatedAssignmentStatement, fn Handler) error {
   396  	if err := fn.Handle(&t.AugTarget); err != nil {
   397  		return err
   398  	}
   399  
   400  	if err := fn.Handle(&t.Expression); err != nil {
   401  		return err
   402  	}
   403  
   404  	if t.StarredExpression != nil {
   405  		return fn.Handle(t.StarredExpression)
   406  	} else if t.YieldExpression != nil {
   407  		return fn.Handle(t.YieldExpression)
   408  	}
   409  
   410  	return nil
   411  }
   412  
   413  func walkArgumentList(t *python.ArgumentList, fn Handler) error {
   414  	for n := range t.PositionalArguments {
   415  		if err := fn.Handle(&t.PositionalArguments[n]); err != nil {
   416  			return err
   417  		}
   418  	}
   419  
   420  	for n := range t.StarredAndKeywordArguments {
   421  		if err := fn.Handle(&t.StarredAndKeywordArguments[n]); err != nil {
   422  			return err
   423  		}
   424  	}
   425  
   426  	for n := range t.KeywordArguments {
   427  		if err := fn.Handle(&t.KeywordArguments[n]); err != nil {
   428  			return err
   429  		}
   430  	}
   431  
   432  	return nil
   433  }
   434  
   435  func walkArgumentListOrComprehension(t *python.ArgumentListOrComprehension, fn Handler) error {
   436  	if t.ArgumentList != nil {
   437  		return fn.Handle(t.ArgumentList)
   438  	} else if t.Comprehension != nil {
   439  		return fn.Handle(t.Comprehension)
   440  	}
   441  
   442  	return nil
   443  }
   444  
   445  func walkAssertStatement(t *python.AssertStatement, fn Handler) error {
   446  	for n := range t.Expressions {
   447  		if err := fn.Handle(&t.Expressions[n]); err != nil {
   448  			return err
   449  		}
   450  	}
   451  
   452  	return nil
   453  }
   454  
   455  func walkAssignmentExpressionAndSuite(t *python.AssignmentExpressionAndSuite, fn Handler) error {
   456  	if err := fn.Handle(&t.AssignmentExpression); err != nil {
   457  		return err
   458  	}
   459  
   460  	return fn.Handle(&t.Suite)
   461  }
   462  
   463  func walkAssignmentExpression(t *python.AssignmentExpression, fn Handler) error {
   464  	return fn.Handle(&t.Expression)
   465  }
   466  
   467  func walkAssignmentStatement(t *python.AssignmentStatement, fn Handler) error {
   468  	for n := range t.TargetLists {
   469  		if err := fn.Handle(&t.TargetLists[n]); err != nil {
   470  			return err
   471  		}
   472  	}
   473  
   474  	if t.StarredExpression != nil {
   475  		return fn.Handle(t.StarredExpression)
   476  	} else if t.YieldExpression != nil {
   477  		return fn.Handle(t.YieldExpression)
   478  	}
   479  
   480  	return nil
   481  }
   482  
   483  func walkAtom(t *python.Atom, fn Handler) error {
   484  	if t.Enclosure != nil {
   485  		return fn.Handle(t.Enclosure)
   486  	}
   487  
   488  	return nil
   489  }
   490  
   491  func walkAugmentedAssignmentStatement(t *python.AugmentedAssignmentStatement, fn Handler) error {
   492  	if err := fn.Handle(&t.AugTarget); err != nil {
   493  		return err
   494  	}
   495  
   496  	if t.ExpressionList != nil {
   497  		return fn.Handle(t.ExpressionList)
   498  	} else if t.YieldExpression != nil {
   499  		return fn.Handle(t.YieldExpression)
   500  	}
   501  
   502  	return nil
   503  }
   504  
   505  func walkAugTarget(t *python.AugTarget, fn Handler) error {
   506  	return fn.Handle(&t.PrimaryExpression)
   507  }
   508  
   509  func walkClassDefinition(t *python.ClassDefinition, fn Handler) error {
   510  	if t.Decorators != nil {
   511  		if err := fn.Handle(t.Decorators); err != nil {
   512  			return err
   513  		}
   514  	}
   515  
   516  	if t.TypeParams != nil {
   517  		if err := fn.Handle(t.TypeParams); err != nil {
   518  			return err
   519  		}
   520  	}
   521  
   522  	if t.Inheritance != nil {
   523  		if err := fn.Handle(t.Inheritance); err != nil {
   524  			return err
   525  		}
   526  	}
   527  
   528  	return fn.Handle(&t.Suite)
   529  }
   530  
   531  func walkComparison(t *python.Comparison, fn Handler) error {
   532  	if err := fn.Handle(&t.OrExpression); err != nil {
   533  		return err
   534  	}
   535  
   536  	for n := range t.Comparisons {
   537  		if err := fn.Handle(&t.Comparisons[n]); err != nil {
   538  			return err
   539  		}
   540  	}
   541  
   542  	return nil
   543  }
   544  
   545  func walkComparisonExpression(t *python.ComparisonExpression, fn Handler) error {
   546  	return fn.Handle(&t.OrExpression)
   547  }
   548  
   549  func walkCompoundStatement(t *python.CompoundStatement, fn Handler) error {
   550  	if t.If != nil {
   551  		return fn.Handle(t.If)
   552  	} else if t.While != nil {
   553  		return fn.Handle(t.While)
   554  	} else if t.For != nil {
   555  		return fn.Handle(t.For)
   556  	} else if t.Try != nil {
   557  		return fn.Handle(t.Try)
   558  	} else if t.With != nil {
   559  		return fn.Handle(t.With)
   560  	} else if t.Func != nil {
   561  		return fn.Handle(t.Func)
   562  	} else if t.Class != nil {
   563  		return fn.Handle(t.Class)
   564  	}
   565  
   566  	return nil
   567  }
   568  
   569  func walkComprehension(t *python.Comprehension, fn Handler) error {
   570  	if err := fn.Handle(&t.AssignmentExpression); err != nil {
   571  		return err
   572  	}
   573  
   574  	return fn.Handle(&t.ComprehensionFor)
   575  }
   576  
   577  func walkComprehensionFor(t *python.ComprehensionFor, fn Handler) error {
   578  	if err := fn.Handle(&t.TargetList); err != nil {
   579  		return err
   580  	}
   581  
   582  	if err := fn.Handle(&t.OrTest); err != nil {
   583  		return err
   584  	}
   585  
   586  	if t.ComprehensionIterator != nil {
   587  		return fn.Handle(t.ComprehensionIterator)
   588  	}
   589  
   590  	return nil
   591  }
   592  
   593  func walkComprehensionIf(t *python.ComprehensionIf, fn Handler) error {
   594  	if err := fn.Handle(&t.OrTest); err != nil {
   595  		return err
   596  	}
   597  
   598  	if t.ComprehensionIterator != nil {
   599  		return fn.Handle(t.ComprehensionIterator)
   600  	}
   601  
   602  	return nil
   603  }
   604  
   605  func walkComprehensionIterator(t *python.ComprehensionIterator, fn Handler) error {
   606  	if t.ComprehensionFor != nil {
   607  		return fn.Handle(t.ComprehensionFor)
   608  	}
   609  
   610  	if t.ComprehensionIf != nil {
   611  		return fn.Handle(t.ComprehensionIf)
   612  	}
   613  
   614  	return nil
   615  }
   616  
   617  func walkConditionalExpression(t *python.ConditionalExpression, fn Handler) error {
   618  	if err := fn.Handle(&t.OrTest); err != nil {
   619  		return err
   620  	}
   621  
   622  	if t.If != nil {
   623  		if err := fn.Handle(t.If); err != nil {
   624  			return err
   625  		}
   626  
   627  		if t.Else != nil {
   628  			return fn.Handle(t.Else)
   629  		}
   630  	}
   631  
   632  	return nil
   633  }
   634  
   635  func walkDecorators(t *python.Decorators, fn Handler) error {
   636  	for n := range t.Decorators {
   637  		if err := fn.Handle(&t.Decorators[n]); err != nil {
   638  			return err
   639  		}
   640  	}
   641  
   642  	return nil
   643  }
   644  
   645  func walkDefParameter(t *python.DefParameter, fn Handler) error {
   646  	if err := fn.Handle(&t.Parameter); err != nil {
   647  		return err
   648  	}
   649  
   650  	if t.Value != nil {
   651  		return fn.Handle(t.Value)
   652  	}
   653  
   654  	return nil
   655  }
   656  
   657  func walkDelStatement(t *python.DelStatement, fn Handler) error {
   658  	return fn.Handle(&t.TargetList)
   659  }
   660  
   661  func walkDictDisplay(t *python.DictDisplay, fn Handler) error {
   662  	for n := range t.DictItems {
   663  		if err := fn.Handle(&t.DictItems[n]); err != nil {
   664  			return err
   665  		}
   666  	}
   667  
   668  	if t.DictComprehension != nil {
   669  		return fn.Handle(t.DictComprehension)
   670  	}
   671  
   672  	return nil
   673  }
   674  
   675  func walkDictItem(t *python.DictItem, fn Handler) error {
   676  	if t.OrExpression != nil {
   677  		if err := fn.Handle(t.OrExpression); err != nil {
   678  			return err
   679  		}
   680  	} else if t.Key != nil && t.Value != nil {
   681  		if err := fn.Handle(t.Key); err != nil {
   682  			return err
   683  		}
   684  
   685  		return fn.Handle(t.Value)
   686  	}
   687  
   688  	return nil
   689  }
   690  
   691  func walkEnclosure(t *python.Enclosure, fn Handler) error {
   692  	if t.ParenthForm != nil {
   693  		return fn.Handle(t.ParenthForm)
   694  	} else if t.ListDisplay != nil {
   695  		return fn.Handle(t.ListDisplay)
   696  	} else if t.DictDisplay != nil {
   697  		return fn.Handle(t.DictDisplay)
   698  	} else if t.SetDisplay != nil {
   699  		return fn.Handle(t.SetDisplay)
   700  	} else if t.GeneratorExpression != nil {
   701  		return fn.Handle(t.GeneratorExpression)
   702  	} else if t.YieldAtom != nil {
   703  		return fn.Handle(t.YieldAtom)
   704  	}
   705  
   706  	return nil
   707  }
   708  
   709  func walkExcept(t *python.Except, fn Handler) error {
   710  	if err := fn.Handle(&t.Expression); err != nil {
   711  		return err
   712  	}
   713  
   714  	return fn.Handle(&t.Suite)
   715  }
   716  
   717  func walkExpression(t *python.Expression, fn Handler) error {
   718  	if t.ConditionalExpression != nil {
   719  		return fn.Handle(t.ConditionalExpression)
   720  	} else if t.LambdaExpression != nil {
   721  		return fn.Handle(t.LambdaExpression)
   722  	}
   723  
   724  	return nil
   725  }
   726  
   727  func walkExpressionList(t *python.ExpressionList, fn Handler) error {
   728  	for n := range t.Expressions {
   729  		if err := fn.Handle(&t.Expressions[n]); err != nil {
   730  			return err
   731  		}
   732  	}
   733  
   734  	return nil
   735  }
   736  
   737  func walkFile(t *python.File, fn Handler) error {
   738  	for n := range t.Statements {
   739  		if err := fn.Handle(&t.Statements[n]); err != nil {
   740  			return err
   741  		}
   742  	}
   743  
   744  	return nil
   745  }
   746  
   747  func walkFlexibleExpression(t *python.FlexibleExpression, fn Handler) error {
   748  	if t.AssignmentExpression != nil {
   749  		return fn.Handle(t.AssignmentExpression)
   750  	} else if t.StarredExpression != nil {
   751  		return fn.Handle(t.StarredExpression)
   752  	}
   753  
   754  	return nil
   755  }
   756  
   757  func walkFlexibleExpressionList(t *python.FlexibleExpressionList, fn Handler) error {
   758  	for n := range t.FlexibleExpressions {
   759  		if err := fn.Handle(&t.FlexibleExpressions[n]); err != nil {
   760  			return err
   761  		}
   762  	}
   763  
   764  	return nil
   765  }
   766  
   767  func walkFlexibleExpressionListOrComprehension(t *python.FlexibleExpressionListOrComprehension, fn Handler) error {
   768  	if t.FlexibleExpressionList != nil {
   769  		return fn.Handle(t.FlexibleExpressionList)
   770  	} else if t.Comprehension != nil {
   771  		return fn.Handle(t.Comprehension)
   772  	}
   773  
   774  	return nil
   775  }
   776  
   777  func walkForStatement(t *python.ForStatement, fn Handler) error {
   778  	if err := fn.Handle(&t.TargetList); err != nil {
   779  		return err
   780  	}
   781  
   782  	if err := fn.Handle(&t.StarredList); err != nil {
   783  		return err
   784  	}
   785  
   786  	if err := fn.Handle(&t.Suite); err != nil {
   787  		return err
   788  	}
   789  
   790  	if t.Else != nil {
   791  		return fn.Handle(t.Else)
   792  	}
   793  
   794  	return nil
   795  }
   796  
   797  func walkFuncDefinition(t *python.FuncDefinition, fn Handler) error {
   798  	if t.Decorators != nil {
   799  		if err := fn.Handle(t.Decorators); err != nil {
   800  			return err
   801  		}
   802  	}
   803  
   804  	if t.TypeParams != nil {
   805  		if err := fn.Handle(t.TypeParams); err != nil {
   806  			return err
   807  		}
   808  	}
   809  
   810  	if err := fn.Handle(&t.ParameterList); err != nil {
   811  		return err
   812  	}
   813  
   814  	if t.Expression != nil {
   815  		if err := fn.Handle(t.Expression); err != nil {
   816  			return err
   817  		}
   818  	}
   819  
   820  	return fn.Handle(&t.Suite)
   821  }
   822  
   823  func walkGeneratorExpression(t *python.GeneratorExpression, fn Handler) error {
   824  	if err := fn.Handle(&t.Expression); err != nil {
   825  	}
   826  
   827  	return fn.Handle(&t.ComprehensionFor)
   828  }
   829  
   830  func walkGlobalStatement(_ *python.GlobalStatement, _ Handler) error {
   831  	return nil
   832  }
   833  
   834  func walkIfStatement(t *python.IfStatement, fn Handler) error {
   835  	if err := fn.Handle(&t.AssignmentExpression); err != nil {
   836  		return err
   837  	}
   838  
   839  	if err := fn.Handle(&t.Suite); err != nil {
   840  		return err
   841  	}
   842  
   843  	for n := range t.Elif {
   844  		if err := fn.Handle(&t.Elif[n]); err != nil {
   845  			return err
   846  		}
   847  	}
   848  
   849  	if t.Else != nil {
   850  		return fn.Handle(t.Else)
   851  	}
   852  
   853  	return nil
   854  }
   855  
   856  func walkImportStatement(t *python.ImportStatement, fn Handler) error {
   857  	if t.RelativeModule != nil {
   858  		if err := fn.Handle(t.RelativeModule); err != nil {
   859  			return err
   860  		}
   861  	}
   862  
   863  	for n := range t.Modules {
   864  		if err := fn.Handle(&t.Modules[n]); err != nil {
   865  			return err
   866  		}
   867  	}
   868  
   869  	return nil
   870  }
   871  
   872  func walkKeywordArgument(t *python.KeywordArgument, fn Handler) error {
   873  	if t.KeywordItem != nil {
   874  		return fn.Handle(t.KeywordItem)
   875  	} else if t.Expression != nil {
   876  		return fn.Handle(t.Expression)
   877  	}
   878  
   879  	return nil
   880  }
   881  
   882  func walkKeywordItem(t *python.KeywordItem, fn Handler) error {
   883  	return fn.Handle(&t.Expression)
   884  }
   885  
   886  func walkLambdaExpression(t *python.LambdaExpression, fn Handler) error {
   887  	if t.ParameterList != nil {
   888  		if err := fn.Handle(t.ParameterList); err != nil {
   889  			return err
   890  		}
   891  	}
   892  
   893  	return fn.Handle(&t.Expression)
   894  }
   895  
   896  func walkModuleAs(t *python.ModuleAs, fn Handler) error {
   897  	return fn.Handle(&t.Module)
   898  }
   899  
   900  func walkModule(_ *python.Module, _ Handler) error {
   901  	return nil
   902  }
   903  
   904  func walkMultiplyExpression(t *python.MultiplyExpression, fn Handler) error {
   905  	if err := fn.Handle(&t.UnaryExpression); err != nil {
   906  		return err
   907  	}
   908  
   909  	if t.MultiplyExpression != nil {
   910  		return fn.Handle(t.MultiplyExpression)
   911  	}
   912  
   913  	return nil
   914  }
   915  
   916  func walkNonLocalStatement(_ *python.NonLocalStatement, _ Handler) error {
   917  	return nil
   918  }
   919  
   920  func walkNotTest(t *python.NotTest, fn Handler) error {
   921  	return fn.Handle(&t.Comparison)
   922  }
   923  
   924  func walkOrExpression(t *python.OrExpression, fn Handler) error {
   925  	if err := fn.Handle(&t.XorExpression); err != nil {
   926  		return err
   927  	}
   928  
   929  	if t.OrExpression != nil {
   930  		return fn.Handle(t.OrExpression)
   931  	}
   932  
   933  	return nil
   934  }
   935  
   936  func walkOrTest(t *python.OrTest, fn Handler) error {
   937  	if err := fn.Handle(&t.AndTest); err != nil {
   938  		return err
   939  	}
   940  
   941  	if t.OrTest != nil {
   942  		return fn.Handle(t.OrTest)
   943  	}
   944  
   945  	return nil
   946  }
   947  
   948  func walkParameter(t *python.Parameter, fn Handler) error {
   949  	if t.Type != nil {
   950  		return fn.Handle(t.Type)
   951  	}
   952  
   953  	return nil
   954  }
   955  
   956  func walkParameterList(t *python.ParameterList, fn Handler) error {
   957  	for n := range t.DefParameters {
   958  		if err := fn.Handle(&t.DefParameters[n]); err != nil {
   959  			return err
   960  		}
   961  	}
   962  
   963  	for n := range t.NoPosOnly {
   964  		if err := fn.Handle(&t.NoPosOnly[n]); err != nil {
   965  			return err
   966  		}
   967  	}
   968  
   969  	if t.StarArg != nil {
   970  		if err := fn.Handle(t.StarArg); err != nil {
   971  			return err
   972  		}
   973  	}
   974  
   975  	for n := range t.StarArgs {
   976  		if err := fn.Handle(&t.StarArgs[n]); err != nil {
   977  			return err
   978  		}
   979  	}
   980  
   981  	if t.StarStarArg != nil {
   982  		return fn.Handle(t.StarStarArg)
   983  	}
   984  
   985  	return nil
   986  }
   987  
   988  func walkPositionalArgument(t *python.PositionalArgument, fn Handler) error {
   989  	if t.AssignmentExpression != nil {
   990  		return fn.Handle(t.AssignmentExpression)
   991  	} else if t.Expression != nil {
   992  		return fn.Handle(t.Expression)
   993  	}
   994  
   995  	return nil
   996  }
   997  
   998  func walkPowerExpression(t *python.PowerExpression, fn Handler) error {
   999  	if err := fn.Handle(&t.PrimaryExpression); err != nil {
  1000  		return err
  1001  	}
  1002  
  1003  	if t.UnaryExpression != nil {
  1004  		return fn.Handle(t.UnaryExpression)
  1005  	}
  1006  
  1007  	return nil
  1008  }
  1009  
  1010  func walkPrimaryExpression(t *python.PrimaryExpression, fn Handler) error {
  1011  	if t.Atom != nil {
  1012  		return fn.Handle(t.Atom)
  1013  	} else if t.PrimaryExpression != nil {
  1014  		if err := fn.Handle(t.PrimaryExpression); err != nil {
  1015  			return err
  1016  		}
  1017  
  1018  		if t.Slicing != nil {
  1019  			return fn.Handle(t.Slicing)
  1020  		} else if t.Call != nil {
  1021  			return fn.Handle(t.Call)
  1022  		}
  1023  	}
  1024  
  1025  	return nil
  1026  }
  1027  
  1028  func walkRaiseStatement(t *python.RaiseStatement, fn Handler) error {
  1029  	if t.Expression != nil {
  1030  		if err := fn.Handle(t.Expression); err != nil {
  1031  			return err
  1032  		}
  1033  
  1034  		if t.From != nil {
  1035  			return fn.Handle(t.From)
  1036  		}
  1037  	}
  1038  
  1039  	return nil
  1040  }
  1041  
  1042  func walkRelativeModule(t *python.RelativeModule, fn Handler) error {
  1043  	if t.Module != nil {
  1044  		return fn.Handle(t.Module)
  1045  	}
  1046  
  1047  	return nil
  1048  }
  1049  
  1050  func walkReturnStatement(t *python.ReturnStatement, fn Handler) error {
  1051  	if t.Expression != nil {
  1052  		return fn.Handle(t.Expression)
  1053  	}
  1054  
  1055  	return nil
  1056  }
  1057  
  1058  func walkShiftExpression(t *python.ShiftExpression, fn Handler) error {
  1059  	if err := fn.Handle(&t.AddExpression); err != nil {
  1060  		return err
  1061  	}
  1062  
  1063  	if t.ShiftExpression != nil {
  1064  		return fn.Handle(t.ShiftExpression)
  1065  	}
  1066  
  1067  	return nil
  1068  }
  1069  
  1070  func walkSimpleStatement(t *python.SimpleStatement, fn Handler) error {
  1071  	if t.AssertStatement != nil {
  1072  		return fn.Handle(t.AssertStatement)
  1073  	} else if t.AssignmentStatement != nil {
  1074  		return fn.Handle(t.AssignmentStatement)
  1075  	} else if t.AugmentedAssignmentStatement != nil {
  1076  		return fn.Handle(t.AugmentedAssignmentStatement)
  1077  	} else if t.AnnotatedAssignmentStatement != nil {
  1078  		return fn.Handle(t.AnnotatedAssignmentStatement)
  1079  	} else if t.DelStatement != nil {
  1080  		return fn.Handle(t.DelStatement)
  1081  	} else if t.ReturnStatement != nil {
  1082  		return fn.Handle(t.ReturnStatement)
  1083  	} else if t.YieldStatement != nil {
  1084  		return fn.Handle(t.YieldStatement)
  1085  	} else if t.RaiseStatement != nil {
  1086  		return fn.Handle(t.RaiseStatement)
  1087  	} else if t.ImportStatement != nil {
  1088  		return fn.Handle(t.ImportStatement)
  1089  	} else if t.GlobalStatement != nil {
  1090  		return fn.Handle(t.GlobalStatement)
  1091  	} else if t.NonLocalStatement != nil {
  1092  		return fn.Handle(t.NonLocalStatement)
  1093  	} else if t.TypeStatement != nil {
  1094  		return fn.Handle(t.TypeStatement)
  1095  	}
  1096  
  1097  	return nil
  1098  }
  1099  
  1100  func walkSliceItem(t *python.SliceItem, fn Handler) error {
  1101  	if t.Expression != nil {
  1102  		return fn.Handle(t.Expression)
  1103  	} else if t.LowerBound != nil && t.UpperBound != nil {
  1104  		if err := fn.Handle(t.LowerBound); err != nil {
  1105  			return err
  1106  		}
  1107  
  1108  		if err := fn.Handle(t.UpperBound); err != nil {
  1109  			return err
  1110  		}
  1111  
  1112  		if t.Stride != nil {
  1113  			return fn.Handle(t.Stride)
  1114  		}
  1115  	}
  1116  
  1117  	return nil
  1118  }
  1119  
  1120  func walkSliceList(t *python.SliceList, fn Handler) error {
  1121  	for n := range t.SliceItems {
  1122  		if err := fn.Handle(&t.SliceItems[n]); err != nil {
  1123  			return err
  1124  		}
  1125  	}
  1126  
  1127  	return nil
  1128  }
  1129  
  1130  func walkStarredExpression(t *python.StarredExpression, fn Handler) error {
  1131  	if t.Expression != nil {
  1132  		return fn.Handle(t.Expression)
  1133  	} else if t.StarredList != nil {
  1134  		return fn.Handle(t.StarredList)
  1135  	}
  1136  
  1137  	return nil
  1138  }
  1139  
  1140  func walkStarredItem(t *python.StarredItem, fn Handler) error {
  1141  	if t.AssignmentExpression != nil {
  1142  		return fn.Handle(t.AssignmentExpression)
  1143  	} else if t.OrExpr != nil {
  1144  		return fn.Handle(t.OrExpr)
  1145  	}
  1146  
  1147  	return nil
  1148  }
  1149  
  1150  func walkStarredList(t *python.StarredList, fn Handler) error {
  1151  	for n := range t.StarredItems {
  1152  		if err := fn.Handle(&t.StarredItems[n]); err != nil {
  1153  			return err
  1154  		}
  1155  	}
  1156  
  1157  	return nil
  1158  }
  1159  
  1160  func walkStarredOrKeyword(t *python.StarredOrKeyword, fn Handler) error {
  1161  	if t.Expression != nil {
  1162  		return fn.Handle(t.Expression)
  1163  	} else if t.KeywordItem != nil {
  1164  		return fn.Handle(t.KeywordItem)
  1165  	}
  1166  
  1167  	return nil
  1168  }
  1169  
  1170  func walkStatement(t *python.Statement, fn Handler) error {
  1171  	if t.CompoundStatement != nil {
  1172  		return fn.Handle(t.CompoundStatement)
  1173  	} else if t.StatementList != nil {
  1174  		return fn.Handle(t.StatementList)
  1175  	}
  1176  
  1177  	return nil
  1178  }
  1179  
  1180  func walkStatementList(t *python.StatementList, fn Handler) error {
  1181  	for n := range t.Statements {
  1182  		if err := fn.Handle(&t.Statements[n]); err != nil {
  1183  			return err
  1184  		}
  1185  	}
  1186  
  1187  	return nil
  1188  }
  1189  
  1190  func walkSuite(t *python.Suite, fn Handler) error {
  1191  	if t.StatementList != nil {
  1192  		return fn.Handle(t.StatementList)
  1193  	}
  1194  
  1195  	for n := range t.Statements {
  1196  		if err := fn.Handle(&t.Statements[n]); err != nil {
  1197  			return err
  1198  		}
  1199  	}
  1200  
  1201  	return nil
  1202  }
  1203  
  1204  func walkTarget(t *python.Target, fn Handler) error {
  1205  	if t.PrimaryExpression != nil {
  1206  		return fn.Handle(t.PrimaryExpression)
  1207  	} else if t.Tuple != nil {
  1208  		return fn.Handle(t.Tuple)
  1209  	} else if t.Array != nil {
  1210  		return fn.Handle(t.Array)
  1211  	} else if t.Star != nil {
  1212  		return fn.Handle(t.Star)
  1213  	}
  1214  
  1215  	return nil
  1216  }
  1217  
  1218  func walkTargetList(t *python.TargetList, fn Handler) error {
  1219  	for n := range t.Targets {
  1220  		if err := fn.Handle(&t.Targets[n]); err != nil {
  1221  			return err
  1222  		}
  1223  	}
  1224  
  1225  	return nil
  1226  }
  1227  
  1228  func walkTryStatement(t *python.TryStatement, fn Handler) error {
  1229  	if err := fn.Handle(&t.Try); err != nil {
  1230  		return err
  1231  	}
  1232  
  1233  	for n := range t.Except {
  1234  		if err := fn.Handle(&t.Except[n]); err != nil {
  1235  			return err
  1236  		}
  1237  	}
  1238  
  1239  	if t.Else != nil {
  1240  		if err := fn.Handle(t.Else); err != nil {
  1241  			return err
  1242  		}
  1243  	}
  1244  
  1245  	if t.Finally != nil {
  1246  		return fn.Handle(t.Finally)
  1247  	}
  1248  
  1249  	return nil
  1250  }
  1251  
  1252  func walkTypeParam(t *python.TypeParam, fn Handler) error {
  1253  	if t.Expression != nil {
  1254  		return fn.Handle(t.Expression)
  1255  	}
  1256  
  1257  	return nil
  1258  }
  1259  
  1260  func walkTypeParams(t *python.TypeParams, fn Handler) error {
  1261  	for n := range t.TypeParams {
  1262  		if err := fn.Handle(&t.TypeParams[n]); err != nil {
  1263  			return err
  1264  		}
  1265  	}
  1266  
  1267  	return nil
  1268  }
  1269  
  1270  func walkTypeStatement(t *python.TypeStatement, fn Handler) error {
  1271  	if t.TypeParams != nil {
  1272  		if err := fn.Handle(t.TypeParams); err != nil {
  1273  			return err
  1274  		}
  1275  	}
  1276  
  1277  	return fn.Handle(&t.Expression)
  1278  }
  1279  
  1280  func walkUnaryExpression(t *python.UnaryExpression, fn Handler) error {
  1281  	if t.PowerExpression != nil {
  1282  		return fn.Handle(t.PowerExpression)
  1283  	} else if t.UnaryExpression != nil {
  1284  		return fn.Handle(t.UnaryExpression)
  1285  	}
  1286  
  1287  	return nil
  1288  }
  1289  
  1290  func walkWhileStatement(t *python.WhileStatement, fn Handler) error {
  1291  	if err := fn.Handle(&t.AssignmentExpression); err != nil {
  1292  		return err
  1293  	}
  1294  
  1295  	if err := fn.Handle(&t.Suite); err != nil {
  1296  		return err
  1297  	}
  1298  
  1299  	if t.Else != nil {
  1300  		return fn.Handle(t.Else)
  1301  	}
  1302  
  1303  	return nil
  1304  }
  1305  
  1306  func walkWithItem(t *python.WithItem, fn Handler) error {
  1307  	if err := fn.Handle(&t.Expression); err != nil {
  1308  		return err
  1309  	}
  1310  
  1311  	if t.Target != nil {
  1312  		return fn.Handle(t.Target)
  1313  	}
  1314  
  1315  	return nil
  1316  }
  1317  
  1318  func walkWithStatement(t *python.WithStatement, fn Handler) error {
  1319  	if err := fn.Handle(&t.Contents); err != nil {
  1320  		return err
  1321  	}
  1322  
  1323  	return fn.Handle(&t.Suite)
  1324  }
  1325  
  1326  func walkWithStatementContents(t *python.WithStatementContents, fn Handler) error {
  1327  	for n := range t.Items {
  1328  		if err := fn.Handle(&t.Items[n]); err != nil {
  1329  			return err
  1330  		}
  1331  	}
  1332  
  1333  	return nil
  1334  }
  1335  
  1336  func walkXorExpression(t *python.XorExpression, fn Handler) error {
  1337  	if err := fn.Handle(&t.AndExpression); err != nil {
  1338  		return err
  1339  	}
  1340  
  1341  	if t.XorExpression != nil {
  1342  		return fn.Handle(t.XorExpression)
  1343  	}
  1344  
  1345  	return nil
  1346  }
  1347  
  1348  func walkYieldExpression(t *python.YieldExpression, fn Handler) error {
  1349  	if t.From != nil {
  1350  		return fn.Handle(t.From)
  1351  	} else if t.ExpressionList != nil {
  1352  		return fn.Handle(t.ExpressionList)
  1353  	}
  1354  
  1355  	return nil
  1356  }
  1357