Issue 13584. Fix for Java/Dart local variable scoping mismatch.

pkg/analyzer_experimental/lib/src/generated/ast.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 98 matching lines @@
    * range.
    *
    * @return the offset from the beginning of the file to the first character in the node's source
    *         range
    */
   int get offset {
     Token beginToken = this.beginToken;
     if (beginToken == null) {
       return -1;
     }
-    return beginToken.offset;
+    return this.beginToken.offset;
   }
 
   /**
    * Return this node's parent node, or `null` if this node is the root of an AST structure.
    *
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
    *
    * @return the parent of this node, or `null` if none
    */
@@ skipping 347 matching lines @@
    *
    * @return the annotations associated with this node
    */
   NodeList<Annotation> get metadata => _metadata;
 
   /**
    * Set the documentation comment associated with this node to the given comment.
    *
    * @param comment the documentation comment to be associated with this node
    */
-  void set documentationComment(Comment comment2) {
-    this._comment = becomeParentOf(comment2);
+  void set documentationComment(Comment comment) {
+    this._comment = becomeParentOf(comment);
   }
 
   /**
    * Set the metadata associated with this node to the given metadata.
    *
    * @param metadata the metadata to be associated with this node
    */
-  void set metadata(List<Annotation> metadata2) {
+  void set metadata(List<Annotation> metadata) {
     this._metadata.clear();
-    this._metadata.addAll(metadata2);
+    this._metadata.addAll(metadata);
   }
   void visitChildren(ASTVisitor visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 170 matching lines @@
    *
    * @return the name of the constructor being invoked or the name of the field being referenced
    */
   Identifier get name => _name;
 
   /**
    * Set the arguments to the constructor being invoked to the given arguments.
    *
    * @param arguments the arguments to the constructor being invoked
    */
-  void set arguments(ArgumentList arguments2) {
-    this._arguments = becomeParentOf(arguments2);
+  void set arguments(ArgumentList arguments) {
+    this._arguments = becomeParentOf(arguments);
   }
 
   /**
    * Set the name of the constructor being invoked to the given name.
    *
    * @param constructorName the name of the constructor being invoked
    */
-  void set constructorName(SimpleIdentifier constructorName2) {
-    this._constructorName = becomeParentOf(constructorName2);
+  void set constructorName(SimpleIdentifier constructorName) {
+    this._constructorName = becomeParentOf(constructorName);
   }
 
   /**
    * Set the element associated with this annotation based.
    *
    * @param element the element to be associated with this identifier
    */
-  void set element(Element element2) {
-    this._element = element2;
+  void set element(Element element) {
+    this._element = element;
   }
 
   /**
    * Set the name of the class defining the constructor that is being invoked or the name of the
    * field that is being referenced to the given name.
    *
    * @param name the name of the constructor being invoked or the name of the field being referenced
    */
-  void set name(Identifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(Identifier name) {
+    this._name = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 /**
  * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
  *
@@ skipping 43 matching lines @@
    *
    * @return the identifier representing the argument being tested
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Set the identifier representing the argument being tested to the given identifier.
    *
    * @param identifier the identifier representing the argument being tested
    */
-  void set identifier(SimpleIdentifier identifier2) {
-    this._identifier = becomeParentOf(identifier2);
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  *
  * <pre>
@@ skipping 245 matching lines @@
    *
    * @return the name of the type being cast to
    */
   TypeName get type => _type;
 
   /**
    * Set the expression used to compute the value being cast to the given expression.
    *
    * @param expression the expression used to compute the value being cast
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the name of the type being cast to to the given name.
    *
    * @param name the name of the type being cast to
    */
   void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
@@ skipping 75 matching lines @@
    * @return the condition that is being asserted to be `true`
    */
   Expression get condition => _condition;
   Token get endToken => semicolon;
 
   /**
    * Set the condition that is being asserted to be `true` to the given expression.
    *
    * @param the condition that is being asserted to be `true`
    */
-  void set condition(Expression condition2) {
-    this._condition = becomeParentOf(condition2);
+  void set condition(Expression condition) {
+    this._condition = becomeParentOf(condition);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class `AssignmentExpression` represent an assignment expression.
  *
  * <pre>
  * assignmentExpression ::=
@@ skipping 490 matching lines @@
    * @return the block representing the body of the function
    */
   Block get block => _block;
   Token get endToken => _block.endToken;
 
   /**
    * Set the block representing the body of the function to the given block.
    *
    * @param block the block representing the body of the function
    */
-  void set block(Block block2) {
-    this._block = becomeParentOf(block2);
+  void set block(Block block) {
+    this._block = becomeParentOf(block);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 /**
  * Instances of the class `BooleanLiteral` represent a boolean literal expression.
  *
  * <pre>
  * booleanLiteral ::=
@@ skipping 170 matching lines @@
    *
    * @return the target of the cascade sections
    */
   Expression get target => _target;
 
   /**
    * Set the target of the cascade sections to the given expression.
    *
    * @param target the target of the cascade sections
    */
-  void set target(Expression target2) {
-    this._target = becomeParentOf(target2);
+  void set target(Expression target) {
+    this._target = becomeParentOf(target);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_target, visitor);
     cascadeSections.accept(visitor);
   }
 }
 /**
  * Instances of the class `CatchClause` represent a catch clause within a try statement.
  *
  * <pre>
@@ skipping 345 matching lines @@
    *
    * @return the with clause for the class
    */
   WithClause get withClause => _withClause;
 
   /**
    * Set the extends clause for this class to the given clause.
    *
    * @param extendsClause the extends clause for this class
    */
-  void set extendsClause(ExtendsClause extendsClause2) {
-    this._extendsClause = becomeParentOf(extendsClause2);
+  void set extendsClause(ExtendsClause extendsClause) {
+    this._extendsClause = becomeParentOf(extendsClause);
   }
 
   /**
    * Set the implements clause for the class to the given clause.
    *
    * @param implementsClause the implements clause for the class
    */
-  void set implementsClause(ImplementsClause implementsClause2) {
-    this._implementsClause = becomeParentOf(implementsClause2);
+  void set implementsClause(ImplementsClause implementsClause) {
+    this._implementsClause = becomeParentOf(implementsClause);
   }
 
   /**
    * Set the name of the class being declared to the given identifier.
    *
    * @param identifier the name of the class being declared
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the with clause for the class to the given clause.
    *
    * @param withClause the with clause for the class
    */
-  void set withClause(WithClause withClause2) {
-    this._withClause = becomeParentOf(withClause2);
+  void set withClause(WithClause withClause) {
+    this._withClause = becomeParentOf(withClause);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
     safelyVisitChild(nativeClause, visitor);
     members.accept(visitor);
@@ skipping 159 matching lines @@
    *
    * @return the with clause for this class
    */
   WithClause get withClause => _withClause;
 
   /**
    * Set the implements clause for this class to the given implements clause.
    *
    * @param implementsClause the implements clause for this class
    */
-  void set implementsClause(ImplementsClause implementsClause2) {
-    this._implementsClause = becomeParentOf(implementsClause2);
+  void set implementsClause(ImplementsClause implementsClause) {
+    this._implementsClause = becomeParentOf(implementsClause);
   }
 
   /**
    * Set the name of the class being declared to the given identifier.
    *
    * @param name the name of the class being declared
    */
-  void set name(SimpleIdentifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(SimpleIdentifier name) {
+    this._name = becomeParentOf(name);
   }
 
   /**
    * Set the name of the superclass of the class being declared to the given name.
    *
    * @param superclass the name of the superclass of the class being declared
    */
-  void set superclass(TypeName superclass2) {
-    this._superclass = becomeParentOf(superclass2);
+  void set superclass(TypeName superclass) {
+    this._superclass = becomeParentOf(superclass);
   }
 
   /**
    * Set the type parameters for the class to the given list of parameters.
    *
    * @param typeParameters the type parameters for the class
    */
-  void set typeParameters(TypeParameterList typeParameters2) {
-    this._typeParameters = becomeParentOf(typeParameters2);
+  void set typeParameters(TypeParameterList typeParameters) {
+    this._typeParameters = becomeParentOf(typeParameters);
   }
 
   /**
    * Set the with clause for this class to the given with clause.
    *
    * @param withClause the with clause for this class
    */
-  void set withClause(WithClause withClause2) {
-    this._withClause = becomeParentOf(withClause2);
+  void set withClause(WithClause withClause) {
+    this._withClause = becomeParentOf(withClause);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
@@ skipping 231 matching lines @@
    *
    * @return the identifier being referenced
    */
   Identifier get identifier => _identifier;
 
   /**
    * Set the identifier being referenced to the given identifier.
    *
    * @param identifier the identifier being referenced
    */
-  void set identifier(Identifier identifier2) {
-    identifier2 = becomeParentOf(identifier2);
+  void set identifier(Identifier identifier) {
+    identifier = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class `CompilationUnit` represent a compilation unit.
  *
  * While the grammar restricts the order of the directives and declarations within a compilation
  * unit, this class does not enforce those restrictions. In particular, the children of a
@@ skipping 195 matching lines @@
    */
   void set resolutionErrors(List<AnalysisError> errors) {
     _resolutionErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    *
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
-  void set scriptTag(ScriptTag scriptTag2) {
-    this._scriptTag = becomeParentOf(scriptTag2);
+  void set scriptTag(ScriptTag scriptTag) {
+    this._scriptTag = becomeParentOf(scriptTag);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (directivesAreBeforeDeclarations()) {
       directives.accept(visitor);
       declarations.accept(visitor);
     } else {
       for (ASTNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
@@ skipping 395 matching lines @@
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
    * Set the element associated with this constructor to the given element.
    *
    * @param element the element associated with this constructor
    */
-  void set element(ConstructorElement element2) {
-    this._element = element2;
+  void set element(ConstructorElement element) {
+    this._element = element;
   }
 
   /**
    * Set the name of the constructor to the given identifier.
    *
    * @param identifier the name of the constructor
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the parameters associated with the constructor to the given list of parameters.
    *
    * @param parameters the parameters associated with the constructor
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the name of the constructor to which this constructor will be redirected to the given
    * constructor name.
    *
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    *          redirected
    */
-  void set redirectedConstructor(ConstructorName redirectedConstructor2) {
-    this._redirectedConstructor = becomeParentOf(redirectedConstructor2);
+  void set redirectedConstructor(ConstructorName redirectedConstructor) {
+    this._redirectedConstructor = becomeParentOf(redirectedConstructor);
   }
 
   /**
    * Set the type of object being created to the given type name.
    *
    * @param typeName the type of object being created
    */
   void set returnType(Identifier typeName) {
     _returnType = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     initializers.accept(visitor);
     safelyVisitChild(_redirectedConstructor, visitor);
     safelyVisitChild(_body, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
-    Token leftMost2 = leftMost([externalKeyword, constKeyword, factoryKeyword]);
-    if (leftMost2 != null) {
-      return leftMost2;
+    Token leftMost = this.leftMost([externalKeyword, constKeyword, factoryKeyword]);
+    if (leftMost != null) {
+      return leftMost;
     }
     return _returnType.beginToken;
   }
 
   /**
    * Return the left-most of the given tokens, or `null` if there are no tokens given or if
    * all of the given tokens are `null`.
    *
    * @param tokens the tokens being compared to find the left-most token
    * @return the left-most of the given tokens
@@ skipping 99 matching lines @@
    * @return the name of the field being initialized
    */
   SimpleIdentifier get fieldName => _fieldName;
 
   /**
    * Set the expression computing the value to which the field will be initialized to the given
    * expression.
    *
    * @param expression the expression computing the value to which the field will be initialized
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the name of the field being initialized to the given identifier.
    *
    * @param identifier the name of the field being initialized
    */
   void set fieldName(SimpleIdentifier identifier) {
     _fieldName = becomeParentOf(identifier);
   }
@@ skipping 104 matching lines @@
    *
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the constructor to the given name.
    *
    * @param name the name of the constructor
    */
-  void set name(SimpleIdentifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(SimpleIdentifier name) {
+    this._name = becomeParentOf(name);
   }
 
   /**
    * Set the element associated with this constructor name based on static type information to the
    * given element.
    *
    * @param element the element to be associated with this constructor name
    */
   void set staticElement(ConstructorElement element) {
     _staticElement = element;
   }
 
   /**
    * Set the name of the type defining the constructor to the given type name.
    *
    * @param type the name of the type defining the constructor
    */
-  void set type(TypeName type2) {
-    this._type = becomeParentOf(type2);
+  void set type(TypeName type) {
+    this._type = becomeParentOf(type);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 /**
  * Instances of the class `ContinueStatement` represent a continue statement.
  *
  * <pre>
@@ skipping 146 matching lines @@
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
   DeclaredIdentifier({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, identifier);
   accept(ASTVisitor visitor) => visitor.visitDeclaredIdentifier(this);
   LocalVariableElement get element {
-    SimpleIdentifier identifier2 = identifier;
-    if (identifier2 == null) {
+    SimpleIdentifier identifier = this.identifier;
+    if (identifier == null) {
       return null;
     }
-    return identifier2.staticElement as LocalVariableElement;
+    return identifier.staticElement as LocalVariableElement;
   }
   Token get endToken => identifier.endToken;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    *
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
@@ skipping 134 matching lines @@
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
 
   /**
    * Set the kind of this parameter to the given kind.
    *
    * @param kind the kind of this parameter
    */
-  void set kind(ParameterKind kind2) {
-    this._kind = kind2;
+  void set kind(ParameterKind kind) {
+    this._kind = kind;
   }
 
   /**
    * Set the formal parameter with which the default value is associated to the given parameter.
    *
    * @param formalParameter the formal parameter with which the default value is associated
    */
   void set parameter(NormalFormalParameter formalParameter) {
     _parameter = becomeParentOf(formalParameter);
   }
@@ skipping 369 matching lines @@
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'export' keyword
    * @param libraryUri the URI of the library being exported
    * @param combinators the combinators used to control which names are exported
    * @param semicolon the semicolon terminating the directive
    */
   ExportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
   LibraryElement get uriElement {
-    Element element2 = element;
-    if (element2 is ExportElement) {
-      return ((element2 as ExportElement)).exportedLibrary;
+    Element element = this.element;
+    if (element is ExportElement) {
+      return ((element as ExportElement)).exportedLibrary;
     }
     return null;
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class `Expression` defines the behavior common to nodes that represent an
@@ skipping 201 matching lines @@
    *
    * @return the expression representing the body of the function
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression representing the body of the function to the given expression.
    *
    * @param expression the expression representing the body of the function
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `ExpressionStatement` wrap an expression as a statement.
  *
  * <pre>
  * expressionStatement ::=
@@ skipping 48 matching lines @@
    * @return the expression that comprises the statement
    */
   Expression get expression => _expression;
   bool get isSynthetic => _expression.isSynthetic && semicolon.isSynthetic;
 
   /**
    * Set the expression that comprises the statement to the given expression.
    *
    * @param expression the expression that comprises the statement
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `ExtendsClause` represent the "extends" clause in a class
  * declaration.
  *
  * <pre>
@@ skipping 249 matching lines @@
    */
   TypeName get type => _type;
   bool get isConst => (keyword is KeywordToken) && identical(((keyword as KeywordToken)).keyword, Keyword.CONST);
   bool get isFinal => (keyword is KeywordToken) && identical(((keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    *
    * @param parameters the parameters of the function-typed parameter
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the name of the declared type of the parameter to the given type name.
    *
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
@@ skipping 152 matching lines @@
    *
    * @return the declaration of the loop variable
    */
   DeclaredIdentifier get loopVariable => _loopVariable;
 
   /**
    * Set the body of the loop to the given block.
    *
    * @param body the body of the loop
    */
-  void set body(Statement body2) {
-    this._body = becomeParentOf(body2);
+  void set body(Statement body) {
+    this._body = becomeParentOf(body);
   }
 
   /**
    * Set the loop variable to the given variable.
    *
    * @param identifier the loop variable
    */
-  void set identifier(SimpleIdentifier identifier2) {
-    this._identifier = becomeParentOf(identifier2);
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * Set the expression evaluated to produce the iterator to the given expression.
    *
    * @param expression the expression evaluated to produce the iterator
    */
   void set iterator(Expression expression) {
     _iterator = becomeParentOf(expression);
   }
@@ skipping 161 matching lines @@
    *
    * @return the declaration of the loop variables, or `null` if there are no variables
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the body of the loop to the given statement.
    *
    * @param body the body of the loop
    */
-  void set body(Statement body2) {
-    this._body = becomeParentOf(body2);
+  void set body(Statement body) {
+    this._body = becomeParentOf(body);
   }
 
   /**
    * Set the condition used to determine when to terminate the loop to the given expression.
    *
    * @param expression the condition used to determine when to terminate the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
   /**
    * Set the initialization expression to the given expression.
    *
    * @param initialization the initialization expression
    */
-  void set initialization(Expression initialization2) {
-    this._initialization = becomeParentOf(initialization2);
+  void set initialization(Expression initialization) {
+    this._initialization = becomeParentOf(initialization);
   }
 
   /**
    * Set the declaration of the loop variables to the given parameter.
    *
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
@@ skipping 370 matching lines @@
    *
    * @return `true` if this function declares a setter
    */
   bool get isSetter => propertyKeyword != null && identical(((propertyKeyword as KeywordToken)).keyword, Keyword.SET);
 
   /**
    * Set the function expression being wrapped to the given function expression.
    *
    * @param functionExpression the function expression being wrapped
    */
-  void set functionExpression(FunctionExpression functionExpression2) {
-    functionExpression2 = becomeParentOf(functionExpression2);
+  void set functionExpression(FunctionExpression functionExpression) {
+    functionExpression = becomeParentOf(functionExpression);
   }
 
   /**
    * Set the name of the function to the given identifier.
    *
    * @param identifier the name of the function
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
@@ skipping 56 matching lines @@
   FunctionDeclarationStatement({FunctionDeclaration functionDeclaration}) : this.full(functionDeclaration);
   accept(ASTVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
   Token get beginToken => functionDeclaration.beginToken;
   Token get endToken => functionDeclaration.endToken;
 
   /**
    * Set the function declaration being wrapped to the given function declaration.
    *
    * @param functionDeclaration the function declaration being wrapped
    */
-  void set functionExpression(FunctionDeclaration functionDeclaration2) {
-    this.functionDeclaration = becomeParentOf(functionDeclaration2);
+  void set functionExpression(FunctionDeclaration functionDeclaration) {
+    this.functionDeclaration = becomeParentOf(functionDeclaration);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(functionDeclaration, visitor);
   }
 }
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
  *
  * <pre>
  * functionExpression ::=
@@ skipping 77 matching lines @@
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
    * Set the parameters associated with the function to the given list of parameters.
    *
    * @param parameters the parameters associated with the function
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class `FunctionExpressionInvocation` represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by [MethodInvocation] nodes. Invocations of
@@ skipping 91 matching lines @@
    *
    * @return the element associated with the function being invoked
    */
   ExecutableElement get propagatedElement => _propagatedElement;
 
   /**
    * Set the list of arguments to the method to the given list.
    *
    * @param argumentList the list of arguments to the method
    */
-  void set argumentList(ArgumentList argumentList2) {
-    this._argumentList = becomeParentOf(argumentList2);
+  void set argumentList(ArgumentList argumentList) {
+    this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the expression producing the function being invoked to the given expression.
    *
    * @param function the expression producing the function being invoked
    */
-  void set function(Expression function2) {
-    function2 = becomeParentOf(function2);
+  void set function(Expression function) {
+    function = becomeParentOf(function);
   }
 
   /**
    * Set the element associated with the function being invoked based on propagated type information
    * to the given element.
    *
    * @param element the element to be associated with the function being invoked
    */
   void set propagatedElement(ExecutableElement element) {
     _propagatedElement = element;
@@ skipping 103 matching lines @@
    *
    * @return the type parameters for the function type
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the name of the function type being declared to the given identifier.
    *
    * @param name the name of the function type being declared
    */
-  void set name(SimpleIdentifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(SimpleIdentifier name) {
+    this._name = becomeParentOf(name);
   }
 
   /**
    * Set the parameters associated with the function type to the given list of parameters.
    *
    * @param parameters the parameters associated with the function type
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the name of the return type of the function type being defined to the given type name.
    *
    * @param typeName the name of the return type of the function type being defined
    */
   void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
   /**
    * Set the type parameters for the function type to the given list of parameters.
    *
    * @param typeParameters the type parameters for the function type
    */
-  void set typeParameters(TypeParameterList typeParameters2) {
-    this._typeParameters = becomeParentOf(typeParameters2);
+  void set typeParameters(TypeParameterList typeParameters) {
+    this._typeParameters = becomeParentOf(typeParameters);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
@@ skipping 69 matching lines @@
    */
   TypeName get returnType => _returnType;
   bool get isConst => false;
   bool get isFinal => false;
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    *
    * @param parameters the parameters of the function-typed parameter
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the return type of the function to the given type.
    *
    * @param returnType the return type of the function
    */
-  void set returnType(TypeName returnType2) {
-    this._returnType = becomeParentOf(returnType2);
+  void set returnType(TypeName returnType) {
+    this._returnType = becomeParentOf(returnType);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class `HideCombinator` represent a combinator that restricts the names
@@ skipping 429 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitImportDirective(this);
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the imported names are
    * not prefixed.
    *
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
   LibraryElement get uriElement {
-    Element element2 = element;
-    if (element2 is ImportElement) {
-      return ((element2 as ImportElement)).importedLibrary;
+    Element element = this.element;
+    if (element is ImportElement) {
+      return ((element as ImportElement)).importedLibrary;
     }
     return null;
   }
 
   /**
    * Set the prefix to be used with the imported names to the given identifier.
    *
    * @param prefix the prefix to be used with the imported names
    */
-  void set prefix(SimpleIdentifier prefix2) {
-    this._prefix = becomeParentOf(prefix2);
+  void set prefix(SimpleIdentifier prefix) {
+    this._prefix = becomeParentOf(prefix);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class `IndexExpression` represent an index expression.
  *
@@ skipping 426 matching lines @@
    *
    * @return `true` if this creation expression is used to invoke a constant constructor
    */
   bool get isConst => keyword is KeywordToken && identical(((keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList(ArgumentList argumentList2) {
-    this._argumentList = becomeParentOf(argumentList2);
+  void set argumentList(ArgumentList argumentList) {
+    this._argumentList = becomeParentOf(argumentList);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `IntegerLiteral` represent an integer literal expression.
  *
  * <pre>
@@ skipping 127 matching lines @@
    * @return the expression to be evaluated for the value to be converted into a string
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression to be evaluated for the value to be converted into a string to the given
    * expression.
    *
    * @param expression the expression to be evaluated for the value to be converted into a string
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `InterpolationString` represent a non-empty substring of an
  * interpolated string.
  *
  * <pre>
@@ skipping 144 matching lines @@
    * @return the name of the type being tested for
    */
   TypeName get type => _type;
 
   /**
    * Set the expression used to compute the value whose type is being tested to the given
    * expression.
    *
    * @param expression the expression used to compute the value whose type is being tested
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the name of the type being tested for to the given name.
    *
    * @param name the name of the type being tested for
    */
   void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
@@ skipping 51 matching lines @@
    *
    * @return the label being associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label being associated with the statement to the given label.
    *
    * @param label the label being associated with the statement
    */
-  void set label(SimpleIdentifier label2) {
-    this._label = becomeParentOf(label2);
+  void set label(SimpleIdentifier label) {
+    this._label = becomeParentOf(label);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class `LabeledStatement` represent a statement that has a label associated
  * with them.
  *
  * <pre>
@@ skipping 48 matching lines @@
    *
    * @return the statement with which the labels are being associated
    */
   Statement get statement => _statement;
 
   /**
    * Set the statement with which the labels are being associated to the given statement.
    *
    * @param statement the statement with which the labels are being associated
    */
-  void set statement(Statement statement2) {
-    this._statement = becomeParentOf(statement2);
+  void set statement(Statement statement) {
+    this._statement = becomeParentOf(statement);
   }
   void visitChildren(ASTVisitor visitor) {
     labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 /**
  * Instances of the class `LibraryDirective` represent a library directive.
  *
  * <pre>
@@ skipping 54 matching lines @@
    *
    * @return the name of the library being defined
    */
   LibraryIdentifier get name => _name;
 
   /**
    * Set the name of the library being defined to the given name.
    *
    * @param name the name of the library being defined
    */
-  void set name(LibraryIdentifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(LibraryIdentifier name) {
+    this._name = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => libraryToken;
 }
 /**
  * Instances of the class `LibraryIdentifier` represent the identifier for a library.
  *
@@ skipping 104 matching lines @@
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral({Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket}) : this.full(constKeyword, typeArguments, leftBracket, elements, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
-    TypeArgumentList typeArguments2 = typeArguments;
-    if (typeArguments2 != null) {
-      return typeArguments2.beginToken;
+    TypeArgumentList typeArguments = this.typeArguments;
+    if (typeArguments != null) {
+      return typeArguments.beginToken;
     }
     return _leftBracket;
   }
   Token get endToken => _rightBracket;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
@@ skipping 101 matching lines @@
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral({Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket}) : this.full(constKeyword, typeArguments, leftBracket, entries, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
-    TypeArgumentList typeArguments2 = typeArguments;
-    if (typeArguments2 != null) {
-      return typeArguments2.beginToken;
+    TypeArgumentList typeArguments = this.typeArguments;
+    if (typeArguments != null) {
+      return typeArguments.beginToken;
     }
     return _leftBracket;
   }
   Token get endToken => _rightBracket;
 
   /**
    * Return the left curly bracket.
    *
    * @return the left curly bracket
    */
@@ skipping 317 matching lines @@
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the parameters associated with the method to the given list of parameters.
    *
    * @param parameters the parameters associated with the method
    */
-  void set parameters(FormalParameterList parameters2) {
-    this._parameters = becomeParentOf(parameters2);
+  void set parameters(FormalParameterList parameters) {
+    this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the return type of the method to the given type name.
    *
    * @param typeName the return type of the method
    */
   void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
@@ skipping 144 matching lines @@
    *
    * @return `true` if this expression is cascaded
    */
   bool get isCascaded => period != null && identical(period.type, TokenType.PERIOD_PERIOD);
 
   /**
    * Set the list of arguments to the method to the given list.
    *
    * @param argumentList the list of arguments to the method
    */
-  void set argumentList(ArgumentList argumentList2) {
-    this._argumentList = becomeParentOf(argumentList2);
+  void set argumentList(ArgumentList argumentList) {
+    this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the name of the method being invoked to the given identifier.
    *
    * @param identifier the name of the method being invoked
    */
   void set methodName(SimpleIdentifier identifier) {
     _methodName = becomeParentOf(identifier);
   }
@@ skipping 84 matching lines @@
    *
    * @return the name associated with the expression
    */
   Label get name => _name;
 
   /**
    * Set the expression with which the name is associated to the given expression.
    *
    * @param expression the expression with which the name is associated
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the name associated with the expression to the given identifier.
    *
    * @param identifier the name associated with the expression
    */
   void set name(Label identifier) {
     _name = becomeParentOf(identifier);
   }
@@ skipping 247 matching lines @@
       return ((parent as DefaultFormalParameter)).kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
    * Set the documentation comment associated with this parameter to the given comment
    *
    * @param comment the documentation comment to be associated with this parameter
    */
-  void set documentationComment(Comment comment2) {
-    this._comment = becomeParentOf(comment2);
+  void set documentationComment(Comment comment) {
+    this._comment = becomeParentOf(comment);
   }
 
   /**
    * Set the name of the parameter being declared to the given identifier.
    *
    * @param identifier the name of the parameter being declared
    */
-  void set identifier(SimpleIdentifier identifier2) {
-    this._identifier = becomeParentOf(identifier2);
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 137 matching lines @@
    *
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
    * Set the expression within the parentheses to the given expression.
    *
    * @param expression the expression within the parentheses
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the left parenthesis to the given token.
    *
    * @param parenthesis the left parenthesis
    */
   void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
@@ skipping 131 matching lines @@
    *
    * @return the name of the library that the containing compilation unit is part of
    */
   LibraryIdentifier get libraryName => _libraryName;
 
   /**
    * Set the name of the library that the containing compilation unit is part of to the given name.
    *
    * @param libraryName the name of the library that the containing compilation unit is part of
    */
-  void set libraryName(LibraryIdentifier libraryName2) {
-    this._libraryName = becomeParentOf(libraryName2);
+  void set libraryName(LibraryIdentifier libraryName) {
+    this._libraryName = becomeParentOf(libraryName);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => partToken;
 }
 /**
  * Instances of the class `PostfixExpression` represent a postfix unary expression.
  *
@@ skipping 429 matching lines @@
       return null;
     }
     return _identifier.staticElement;
   }
 
   /**
    * Set the identifier being prefixed to the given identifier.
    *
    * @param identifier the identifier being prefixed
    */
-  void set identifier(SimpleIdentifier identifier2) {
-    this._identifier = becomeParentOf(identifier2);
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
    * identifier.
    *
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
   void set prefix(SimpleIdentifier identifier) {
     _prefix = becomeParentOf(identifier);
@@ skipping 220 matching lines @@
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList(ArgumentList argumentList2) {
-    this._argumentList = becomeParentOf(argumentList2);
+  void set argumentList(ArgumentList argumentList) {
+    this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
@@ skipping 99 matching lines @@
    *
    * @return the expression computing the value to be returned
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression computing the value to be returned to the given expression.
    *
    * @param expression the expression computing the value to be returned
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `ScriptTag` represent the script tag that can optionally occur at
  * the beginning of a compilation unit.
  *
  * <pre>
@@ skipping 704 matching lines @@
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList(ArgumentList argumentList2) {
-    this._argumentList = becomeParentOf(argumentList2);
+  void set argumentList(ArgumentList argumentList) {
+    this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
@@ skipping 87 matching lines @@
    *
    * @return the expression controlling whether the statements will be executed
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression controlling whether the statements will be executed to the given expression.
    *
    * @param expression the expression controlling whether the statements will be executed
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 /**
  * Instances of the class `SwitchDefault` represent the default case in a switch statement.
  *
@@ skipping 195 matching lines @@
    * @return the expression used to determine which of the switch members will be selected
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression used to determine which of the switch members will be selected to the given
    * expression.
    *
    * @param expression the expression used to determine which of the switch members will be selected
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     members.accept(visitor);
   }
 }
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
@@ skipping 131 matching lines @@
    *
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression computing the exception to be thrown to the given expression.
    *
    * @param expression the expression computing the exception to be thrown
    */
-  void set expression(Expression expression2) {
-    this._expression = becomeParentOf(expression2);
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `TopLevelVariableDeclaration` represent the declaration of one or
  * more top-level variables of the same type.
  *
  * <pre>
@@ skipping 371 matching lines @@
    */
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the type arguments associated with the type to the given type arguments.
    *
    * @param typeArguments the type arguments associated with the type
    */
-  void set typeArguments(TypeArgumentList typeArguments2) {
-    this._typeArguments = becomeParentOf(typeArguments2);
+  void set typeArguments(TypeArgumentList typeArguments) {
+    this._typeArguments = becomeParentOf(typeArguments);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * Instances of the class `TypeParameter` represent a type parameter.
  *
  * <pre>
@@ skipping 254 matching lines @@
    *
    * @return the element associated with this directive
    */
   Element get uriElement;
 
   /**
    * Set the URI referenced by this directive to the given URI.
    *
    * @param uri the URI referenced by this directive
    */
-  void set uri(StringLiteral uri2) {
-    this._uri = becomeParentOf(uri2);
+  void set uri(StringLiteral uri) {
+    this._uri = becomeParentOf(uri);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 /**
  * Instances of the class `VariableDeclaration` represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class
  * [VariableDeclarationList].
@@ skipping 110 matching lines @@
   bool get isFinal {
     ASTNode parent = this.parent;
     return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isFinal;
   }
 
   /**
    * Set the expression used to compute the initial value for the variable to the given expression.
    *
    * @param initializer the expression used to compute the initial value for the variable
    */
-  void set initializer(Expression initializer2) {
-    this._initializer = becomeParentOf(initializer2);
+  void set initializer(Expression initializer) {
+    this._initializer = becomeParentOf(initializer);
   }
 
   /**
    * Set the name of the variable being declared to the given identifier.
    *
    * @param name the name of the variable being declared
    */
-  void set name(SimpleIdentifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(SimpleIdentifier name) {
+    this._name = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class `VariableDeclarationList` represent the declaration of one or more
@@ skipping 153 matching lines @@
    *
    * @return the variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the variables being declared to the given list of variables.
    *
    * @param variableList the variables being declared
    */
-  void set variables(VariableDeclarationList variableList2) {
-    this._variableList = becomeParentOf(variableList2);
+  void set variables(VariableDeclarationList variableList) {
+    this._variableList = becomeParentOf(variableList);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 /**
  * Instances of the class `WhileStatement` represent a while statement.
  *
  * <pre>
  * whileStatement ::=
@@ skipping 140 matching lines @@
   WithClause({Token withKeyword, List<TypeName> mixinTypes}) : this.full(withKeyword, mixinTypes);
   accept(ASTVisitor visitor) => visitor.visitWithClause(this);
   Token get beginToken => withKeyword;
   Token get endToken => mixinTypes.endToken;
 
   /**
    * Set the token representing the 'with' keyword to the given token.
    *
    * @param withKeyword the token representing the 'with' keyword
    */
-  void set mixinKeyword(Token withKeyword2) {
-    this.withKeyword = withKeyword2;
+  void set mixinKeyword(Token withKeyword) {
+    this.withKeyword = withKeyword;
   }
   void visitChildren(ASTVisitor visitor) {
     mixinTypes.accept(visitor);
   }
 }
 /**
  * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure, similar to [GeneralizingASTVisitor]. This
  * visitor uses a breadth-first ordering rather than the depth-first ordering of
  * [GeneralizingASTVisitor].
@@ skipping 2429 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }