Generate unique names less aggressively.

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;
@@ skipping 71 matching lines @@
     }
     return endToken2.offset + endToken2.length - beginToken2.offset;
   }
   /**
    * Return the offset from the beginning of the file to the first character in the node's source
    * range.
    * @return the offset from the beginning of the file to the first character in the node's source
    * range
    */
   int get offset {
-    Token beginToken3 = beginToken;
-    if (beginToken3 == null) {
+    Token beginToken2 = beginToken;
+    if (beginToken2 == null) {
       return -1;
     }
     return beginToken.offset;
   }
   /**
    * Return this node's parent node, or {@code null} if this node is the root of an AST structure.
    * <p>
    * 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 {@code null} if none
@@ skipping 490 matching lines @@
    * @param constructorName the name of the constructor being invoked
    */
   void set constructorName(SimpleIdentifier constructorName2) {
     this._constructorName = becomeParentOf(constructorName2);
   }
   /**
    * 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 name3) {
-    this._name = becomeParentOf(name3);
+  void set name(Identifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * Set the period before the constructor name to the given token.
    * @param period the period before the constructor name
    */
   void set period(Token period2) {
     this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
@@ skipping 42 matching lines @@
   SimpleIdentifier get identifier => _identifier;
   /**
    * Return the token representing the question mark.
    * @return the token representing the question mark
    */
   Token get question => _question;
   /**
    * 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 identifier8) {
-    this._identifier = becomeParentOf(identifier8);
+  void set identifier(SimpleIdentifier identifier2) {
+    this._identifier = becomeParentOf(identifier2);
   }
   /**
    * Set the token representing the question mark to the given token.
    * @param question the token representing the question mark
    */
   void set question(Token question2) {
     this._question = question2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
@@ skipping 288 matching lines @@
    * Set the condition that is being asserted to be {@code true} to the given expression.
    * @param the condition that is being asserted to be {@code true}
    */
   void set condition(Expression condition2) {
     this._condition = becomeParentOf(condition2);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword(Token keyword3) {
-    this._keyword = keyword3;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param the left parenthesis
    */
   void set leftParenthesis(Token leftParenthesis2) {
     this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the right parenthesis to the given token.
@@ skipping 78 matching lines @@
   Token get operator => _operator;
   /**
    * Return the expression used to compute the right hand side.
    * @return the expression used to compute the right hand side
    */
   Expression get rightHandSide => _rightHandSide;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element(MethodElement element3) {
-    this._element = element3;
+  void set element(MethodElement element2) {
+    this._element = element2;
   }
   /**
    * Return the expression used to compute the left hand side.
    * @param expression the expression used to compute the left hand side
    */
   void set leftHandSide(Expression expression) {
     _leftHandSide = becomeParentOf(expression);
   }
   /**
    * Set the assignment operator being applied to the given operator.
@@ skipping 79 matching lines @@
   Token get operator => _operator;
   /**
    * Return the expression used to compute the right operand.
    * @return the expression used to compute the right operand
    */
   Expression get rightOperand => _rightOperand;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element(MethodElement element4) {
-    this._element = element4;
+  void set element(MethodElement element2) {
+    this._element = element2;
   }
   /**
    * Set the expression used to compute the left operand to the given expression.
    * @param expression the expression used to compute the left operand
    */
   void set leftOperand(Expression expression) {
     _leftOperand = becomeParentOf(expression);
   }
   /**
    * Set the binary operator being applied to the given operator.
    * @return the binary operator being applied
    */
-  void set operator(Token operator3) {
-    this._operator = operator3;
+  void set operator(Token operator2) {
+    this._operator = operator2;
   }
   /**
    * Set the expression used to compute the right operand to the given expression.
    * @param expression the expression used to compute the right operand
    */
   void set rightOperand(Expression expression) {
     _rightOperand = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftOperand, visitor);
@@ skipping 169 matching lines @@
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value(bool value4) {
-    this._value = value4;
+  void set value(bool value2) {
+    this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code BreakStatement} represent a break statement.
  * <pre>
  * breakStatement ::=
  * 'break' {@link SimpleIdentifier label}? ';'
  * </pre>
@@ skipping 45 matching lines @@
   SimpleIdentifier get label => _label;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'break' keyword to the given token.
    * @param keyword the token representing the 'break' keyword
    */
-  void set keyword(Token keyword4) {
-    this._keyword = keyword4;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the label associated with the statement to the given identifier.
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon3) {
-    this._semicolon = semicolon3;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class {@code CascadeExpression} represent a sequence of cascaded expressions:
  * expressions that share a common target. There are three kinds of expressions that can be used in
  * a cascade expression: {@link IndexExpression}, {@link MethodInvocation} and{@link PropertyAccess}.
  * <pre>
@@ skipping 430 matching lines @@
    * Set the token representing the 'class' keyword to the given token.
    * @param classKeyword the token representing the 'class' keyword
    */
   void set classKeyword(Token classKeyword2) {
     this._classKeyword = classKeyword2;
   }
   /**
    * Set the extends clause for this class to the given clause.
    * @param extendsClause the extends clause for this class
    */
-  void set extendsClause(ExtendsClause extendsClause3) {
-    this._extendsClause = becomeParentOf(extendsClause3);
+  void set extendsClause(ExtendsClause extendsClause2) {
+    this._extendsClause = becomeParentOf(extendsClause2);
   }
   /**
    * Set the implements clause for the class to the given clause.
    * @param implementsClause the implements clause for the class
    */
-  void set implementsClause(ImplementsClause implementsClause4) {
-    this._implementsClause = becomeParentOf(implementsClause4);
+  void set implementsClause(ImplementsClause implementsClause2) {
+    this._implementsClause = becomeParentOf(implementsClause2);
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket(Token leftBracket3) {
-    this._leftBracket = leftBracket3;
+  void set leftBracket(Token leftBracket2) {
+    this._leftBracket = leftBracket2;
   }
   /**
    * 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 right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket(Token rightBracket3) {
-    this._rightBracket = rightBracket3;
+  void set rightBracket(Token rightBracket2) {
+    this._rightBracket = rightBracket2;
   }
   /**
    * Set the type parameters for the class to the given list of type parameters.
    * @param typeParameters the type parameters for the class
    */
   void set typeParameters(TypeParameterList typeParameters2) {
     this._typeParameters = typeParameters2;
   }
   /**
    * Set the with clause for the class to the given clause.
    * @param withClause the with clause for the class
    */
-  void set withClause(WithClause withClause4) {
-    this._withClause = becomeParentOf(withClause4);
+  void set withClause(WithClause withClause2) {
+    this._withClause = becomeParentOf(withClause2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(documentationComment, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
     members.accept(visitor);
   }
@@ skipping 137 matching lines @@
   TypeParameterList get typeParameters => _typeParameters;
   /**
    * Return the with clause for this class.
    * @return the with clause for this class
    */
   WithClause get withClause => _withClause;
   /**
    * Set the token for the 'abstract' keyword to the given token.
    * @param abstractKeyword the token for the 'abstract' keyword
    */
-  void set abstractKeyword(Token abstractKeyword3) {
-    this._abstractKeyword = abstractKeyword3;
+  void set abstractKeyword(Token abstractKeyword2) {
+    this._abstractKeyword = abstractKeyword2;
   }
   /**
    * Set the token for the '=' separating the name from the definition to the given token.
    * @param equals the token for the '=' separating the name from the definition
    */
-  void set equals(Token equals4) {
-    this._equals = equals4;
+  void set equals(Token equals2) {
+    this._equals = equals2;
   }
   /**
    * Set the implements clause for this class to the given implements clause.
    * @param implementsClause the implements clause for this class
    */
-  void set implementsClause(ImplementsClause implementsClause5) {
-    this._implementsClause = becomeParentOf(implementsClause5);
+  void set implementsClause(ImplementsClause implementsClause2) {
+    this._implementsClause = becomeParentOf(implementsClause2);
   }
   /**
    * 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 name4) {
-    this._name = becomeParentOf(name4);
+  void set name(SimpleIdentifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * 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);
   }
   /**
    * 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 typeParameters3) {
-    this._typeParameters = becomeParentOf(typeParameters3);
+  void set typeParameters(TypeParameterList typeParameters2) {
+    this._typeParameters = becomeParentOf(typeParameters2);
   }
   /**
    * Set the with clause for this class to the given with clause.
    * @param withClause the with clause for this class
    */
-  void set withClause(WithClause withClause5) {
-    this._withClause = becomeParentOf(withClause5);
+  void set withClause(WithClause withClause2) {
+    this._withClause = becomeParentOf(withClause2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
@@ skipping 28 matching lines @@
    * Return the keyword specifying what kind of processing is to be done on the imported names.
    * @return the keyword specifying what kind of processing is to be done on the imported names
    */
   Token get keyword => _keyword;
   /**
    * Set the keyword specifying what kind of processing is to be done on the imported names to the
    * given token.
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    * names
    */
-  void set keyword(Token keyword5) {
-    this._keyword = keyword5;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
 }
 /**
  * Instances of the class {@code Comment} represent a comment within the source code.
  * <pre>
  * comment ::=
  * endOfLineComment
  * | blockComment
  * | documentationComment
  * endOfLineComment ::=
@@ skipping 165 matching lines @@
   Identifier get identifier => _identifier;
   /**
    * Return the token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
    * @return the token representing the 'new' keyword
    */
   Token get newKeyword => _newKeyword;
   /**
    * Set the identifier being referenced to the given identifier.
    * @param identifier the identifier being referenced
    */
-  void set identifier(Identifier identifier26) {
-    identifier26 = becomeParentOf(identifier26);
+  void set identifier(Identifier identifier2) {
+    identifier2 = becomeParentOf(identifier2);
   }
   /**
    * Set the token representing the 'new' keyword to the given token.
    * @param newKeyword the token representing the 'new' keyword
    */
   void set newKeyword(Token newKeyword2) {
     this._newKeyword = newKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
@@ skipping 111 matching lines @@
     } else if (parserErrors.length == 0) {
       return resolverErrors;
     } else {
       List<AnalysisError> allErrors = new List<AnalysisError>(parserErrors.length + resolverErrors.length);
       JavaSystem.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
       JavaSystem.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
       return allErrors;
     }
   }
   int get length {
-    Token endToken3 = endToken;
-    if (endToken3 == null) {
+    Token endToken2 = endToken;
+    if (endToken2 == null) {
       return 0;
     }
-    return endToken3.offset + endToken3.length;
+    return endToken2.offset + endToken2.length;
   }
   /**
    * Get the {@link LineInfo} object for this compilation unit.
    * @return the associated {@link LineInfo}
    */
   LineInfo get lineInfo => _lineInfo;
   int get offset => 0;
   /**
    * Return an array containing all of the parsing errors associated with the receiver.
    * @return an array of errors (not {@code null}, contains no {@code null}s).
    */
   List<AnalysisError> get parsingErrors => _parsingErrors;
   /**
    * Return an array containing all of the resolution errors associated with the receiver. If the
    * receiver has not been resolved, then return {@code null}.
    * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
    * been resolved
    */
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
   /**
    * Return the script tag at the beginning of the compilation unit, or {@code null} if there is no
    * script tag in this compilation unit.
    * @return the script tag at the beginning of the compilation unit
    */
   ScriptTag get scriptTag => _scriptTag;
   /**
    * Set the element associated with this compilation unit to the given element.
    * @param element the element associated with this compilation unit
    */
-  void set element(CompilationUnitElement element5) {
-    this._element = element5;
+  void set element(CompilationUnitElement element2) {
+    this._element = element2;
   }
   /**
    * Set the {@link LineInfo} object for this compilation unit.
    * @param errors LineInfo to associate with this compilation unit
    */
   void set lineInfo(LineInfo lineInfo2) {
     this._lineInfo = lineInfo2;
   }
   /**
    * Called to cache the parsing errors when the unit is parsed.
@@ skipping 177 matching lines @@
    * expression.
    * @param expression the expression that is executed if the condition evaluates to {@code false}
    */
   void set elseExpression(Expression expression) {
     _elseExpression = becomeParentOf(expression);
   }
   /**
    * Set the token used to separate the condition from the then expression to the given token.
    * @param question the token used to separate the condition from the then expression
    */
-  void set question(Token question3) {
-    this._question = question3;
+  void set question(Token question2) {
+    this._question = question2;
   }
   /**
    * Set the expression that is executed if the condition evaluates to {@code true} to the given
    * expression.
    * @param expression the expression that is executed if the condition evaluates to {@code true}
    */
   void set thenExpression(Expression expression) {
     _thenExpression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
@@ skipping 205 matching lines @@
    * Set the token for the 'const' keyword to the given token.
    * @param constKeyword the token for the 'const' keyword
    */
   void set constKeyword(Token constKeyword2) {
     this._constKeyword = constKeyword2;
   }
   /**
    * Set the element associated with this constructor to the given element.
    * @param element the element associated with this constructor
    */
-  void set element(ConstructorElement element6) {
-    this._element = element6;
+  void set element(ConstructorElement element2) {
+    this._element = element2;
   }
   /**
    * Set the token for the 'external' keyword to the given token.
    * @param externalKeyword the token for the 'external' keyword
    */
   void set externalKeyword(Token externalKeyword2) {
     this._externalKeyword = externalKeyword2;
   }
   /**
    * Set the token for the 'factory' keyword to the given token.
@@ skipping 13 matching lines @@
    * 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);
   }
   /**
    * Set the token for the period before the constructor name to the given token.
    * @param period the token for the period before the constructor name
    */
-  void set period(Token period3) {
-    this._period = period3;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * 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);
   }
@@ skipping 131 matching lines @@
   /**
    * Return the token for the period after the 'this' keyword, or {@code null} if there is no 'this'
    * keyword.
    * @return the token for the period after the 'this' keyword
    */
   Token get period => _period;
   /**
    * Set the token for the equal sign between the field name and the expression to the given token.
    * @param equals the token for the equal sign between the field name and the expression
    */
-  void set equals(Token equals5) {
-    this._equals = equals5;
+  void set equals(Token equals2) {
+    this._equals = equals2;
   }
   /**
    * 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 expression3) {
-    this._expression = becomeParentOf(expression3);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * 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);
   }
   /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
-  void set keyword(Token keyword6) {
-    this._keyword = keyword6;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the token for the period after the 'this' keyword to the given token.
    * @param period the token for the period after the 'this' keyword
    */
-  void set period(Token period4) {
-    this._period = period4;
+  void set period(Token period2) {
+    this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ConstructorInitializer} defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  * <pre>
@@ skipping 76 matching lines @@
   Token get period => _period;
   /**
    * Return the name of the type defining the constructor.
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
   /**
    * Set the element associated with this constructor name to the given element.
    * @param element the element associated with this constructor name
    */
-  void set element(ConstructorElement element7) {
-    this._element = element7;
+  void set element(ConstructorElement element2) {
+    this._element = element2;
   }
   /**
    * Set the name of the constructor to the given name.
    * @param name the name of the constructor
    */
-  void set name(SimpleIdentifier name5) {
-    this._name = becomeParentOf(name5);
+  void set name(SimpleIdentifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * Return the token for the period before the constructor name to the given token.
    * @param period the token for the period before the constructor name
    */
-  void set period(Token period5) {
-    this._period = period5;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * 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 visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
@@ skipping 54 matching lines @@
   SimpleIdentifier get label => _label;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'continue' keyword to the given token.
    * @param keyword the token representing the 'continue' keyword
    */
-  void set keyword(Token keyword7) {
-    this._keyword = keyword7;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the label associated with the statement to the given label.
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon4) {
-    this._semicolon = semicolon4;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * The abstract class {@code Declaration} defines the behavior common to nodes that represent the
  * declaration of a name. Each declared name is visible within a name scope.
  * @coverage dart.engine.ast
  */
@@ skipping 58 matching lines @@
    * Initialize a newly created formal parameter.
    * @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 identifier12 = identifier;
-    if (identifier12 == null) {
+    SimpleIdentifier identifier2 = identifier;
+    if (identifier2 == null) {
       return null;
     }
-    return identifier12.element as LocalVariableElement;
+    return identifier2.element as LocalVariableElement;
   }
   Token get endToken => _identifier.endToken;
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get identifier => _identifier;
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword.
    * @return the token representing either the 'final', 'const' or 'var' keyword
@@ skipping 14 matching lines @@
    * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return {@code false} even though they are implicitly
    * final.
    * @return {@code true} if this variable was declared with the 'final' modifier
    */
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword8) {
-    this._keyword = keyword8;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * 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);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 116 matching lines @@
    * 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);
   }
   /**
    * Set the token separating the parameter from the default value to the given token.
    * @param separator the token separating the parameter from the default value
    */
-  void set separator(Token separator3) {
-    this._separator = separator3;
+  void set separator(Token separator2) {
+    this._separator = separator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 /**
  * The abstract class {@code Directive} defines the behavior common to nodes that represent a
  * directive.
  * <pre>
@@ skipping 29 matching lines @@
   /**
    * Return the token representing the keyword that introduces this directive ('import', 'export',
    * 'library' or 'part').
    * @return the token representing the keyword that introduces this directive
    */
   Token get keyword;
   /**
    * Set the element associated with this directive to the given element.
    * @param element the element associated with this directive
    */
-  void set element(Element element8) {
-    this._element = element8;
+  void set element(Element element2) {
+    this._element = element2;
   }
 }
 /**
  * Instances of the class {@code DoStatement} represent a do statement.
  * <pre>
  * doStatement ::=
  * 'do' {@link Statement body} 'while' '(' {@link Expression condition} ')' ';'
  * </pre>
  * @coverage dart.engine.ast
  */
@@ skipping 126 matching lines @@
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon5) {
-    this._semicolon = semicolon5;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param whileKeyword the token representing the 'while' keyword
    */
   void set whileKeyword(Token whileKeyword2) {
     this._whileKeyword = whileKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_body, visitor);
@@ skipping 45 matching lines @@
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   double get value => _value;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal(Token literal3) {
-    this._literal = literal3;
+  void set literal(Token literal2) {
+    this._literal = literal2;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value(double value5) {
-    this._value = value5;
+  void set value(double value2) {
+    this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyFunctionBody} represent an empty function body, which can only
  * appear in constructors or abstract methods.
  * <pre>
  * emptyFunctionBody ::=
  * ';'
@@ skipping 23 matching lines @@
   /**
    * Return the token representing the semicolon that marks the end of the function body.
    * @return the token representing the semicolon that marks the end of the function body
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the semicolon that marks the end of the function body to the given
    * token.
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
-  void set semicolon(Token semicolon6) {
-    this._semicolon = semicolon6;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyStatement} represent an empty statement.
  * <pre>
  * emptyStatement ::=
  * ';'
  * </pre>
@@ skipping 21 matching lines @@
   Token get endToken => _semicolon;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon7) {
-    this._semicolon = semicolon7;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
@@ skipping 56 matching lines @@
   Type2 _propagatedType;
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known, and this expression corresponds to one of the
    * parameters of the function being invoked, then return the parameter element representing the
    * parameter to which the value of this expression will be bound. Otherwise, return {@code null}.
    * @return the parameter element representing the parameter to which the value of this expression
    * will be bound
    */
   ParameterElement get parameterElement {
-    ASTNode parent3 = parent;
-    if (parent3 is ArgumentList) {
-      return ((parent3 as ArgumentList)).getParameterElementFor(this);
+    ASTNode parent2 = parent;
+    if (parent2 is ArgumentList) {
+      return ((parent2 as ArgumentList)).getParameterElementFor(this);
     }
     return null;
   }
   /**
    * Return the propagated type of this expression, or {@code null} if type propagation has not been
    * performed on the AST structure.
    * @return the propagated type of this expression
    */
   Type2 get propagatedType => _propagatedType;
   /**
@@ skipping 84 matching lines @@
   Token get functionDefinition => _functionDefinition;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * 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 expression4) {
-    this._expression = becomeParentOf(expression4);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the token introducing the expression that represents the body of the function to the given
    * token.
    * @param functionDefinition the function definition token
    */
   void set functionDefinition(Token functionDefinition2) {
     this._functionDefinition = functionDefinition2;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon8) {
-    this._semicolon = semicolon8;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExpressionStatement} wrap an expression as a statement.
  * <pre>
  * expressionStatement ::={@link Expression expression}? ';'
  * </pre>
@@ skipping 40 matching lines @@
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   bool 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 expression5) {
-    this._expression = becomeParentOf(expression5);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon9) {
-    this._semicolon = semicolon9;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExtendsClause} represent the "extends" clause in a class
  * declaration.
  * <pre>
  * extendsClause ::=
@@ skipping 34 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the name of the class that is being extended.
    * @return the name of the class that is being extended
    */
   TypeName get superclass => _superclass;
   /**
    * Set the token representing the 'extends' keyword to the given token.
    * @param keyword the token representing the 'extends' keyword
    */
-  void set keyword(Token keyword9) {
-    this._keyword = keyword9;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the name of the class that is being extended to the given name.
    * @param name the name of the class that is being extended
    */
   void set superclass(TypeName name) {
     _superclass = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_superclass, visitor);
@@ skipping 66 matching lines @@
    * Set the fields being declared to the given list of variables.
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
   /**
    * Set the token representing the 'static' keyword to the given token.
    * @param keyword the token representing the 'static' keyword
    */
-  void set keyword(Token keyword10) {
-    this._keyword = keyword10;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon(Token semicolon10) {
-    this._semicolon = semicolon10;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     }
     return _fieldList.beginToken;
@@ skipping 82 matching lines @@
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword11) {
-    this._keyword = keyword11;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the token representing the period to the given token.
    * @param period the token representing the period
    */
-  void set period(Token period6) {
-    this._period = period6;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * Set the token representing the 'this' keyword to the given token.
    * @param thisToken the token representing the 'this' keyword
    */
   void set thisToken(Token thisToken2) {
     this._thisToken = thisToken2;
   }
   /**
    * Set the name of the declared type of the parameter to the given type name.
@@ skipping 135 matching lines @@
    * 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);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis(Token leftParenthesis3) {
-    this._leftParenthesis = leftParenthesis3;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the declaration of the loop variable to the given variable.
    * @param variable the declaration of the loop variable
    */
   void set loopVariable(DeclaredIdentifier variable) {
     _loopVariable = becomeParentOf(variable);
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis(Token rightParenthesis3) {
-    this._rightParenthesis = rightParenthesis3;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code ForStatement} represent a for statement.
  * <pre>
@@ skipping 139 matching lines @@
   NodeList<Expression> get updaters => _updaters;
   /**
    * Return the declaration of the loop variables, or {@code null} if there are no variables.
    * @return the declaration of the loop variables, or {@code 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 body3) {
-    this._body = becomeParentOf(body3);
+  void set body(Statement body2) {
+    this._body = becomeParentOf(body2);
   }
   /**
    * 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 token representing the 'for' keyword to the given token.
    * @param forKeyword the token representing the 'for' keyword
    */
-  void set forKeyword(Token forKeyword3) {
-    this._forKeyword = forKeyword3;
+  void set forKeyword(Token forKeyword2) {
+    this._forKeyword = forKeyword2;
   }
   /**
    * Set the initialization expression to the given expression.
    * @param initialization the initialization expression
    */
   void set initialization(Expression initialization2) {
     this._initialization = becomeParentOf(initialization2);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis(Token leftParenthesis4) {
-    this._leftParenthesis = leftParenthesis4;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the semicolon separating the initializer and the condition to the given token.
    * @param leftSeparator the semicolon separating the initializer and the condition
    */
   void set leftSeparator(Token leftSeparator2) {
     this._leftSeparator = leftSeparator2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis(Token rightParenthesis4) {
-    this._rightParenthesis = rightParenthesis4;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   /**
    * Set the semicolon separating the condition and the updater to the given token.
    * @param rightSeparator the semicolon separating the condition and the updater
    */
   void set rightSeparator(Token rightSeparator2) {
     this._rightSeparator = rightSeparator2;
   }
   /**
    * Set the declaration of the loop variables to the given parameter.
@@ skipping 17 matching lines @@
  * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
  * @coverage dart.engine.ast
  */
 abstract class FormalParameter extends ASTNode {
   /**
    * Return the element representing this parameter, or {@code null} if this parameter has not been
    * resolved.
    * @return the element representing this parameter
    */
   ParameterElement get element {
-    SimpleIdentifier identifier13 = identifier;
-    if (identifier13 == null) {
+    SimpleIdentifier identifier2 = identifier;
+    if (identifier2 == null) {
       return null;
     }
-    return identifier13.element as ParameterElement;
+    return identifier2.element as ParameterElement;
   }
   /**
    * Return the name of the parameter being declared.
    * @return the name of the parameter being declared
    */
   SimpleIdentifier get identifier;
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
@@ skipping 244 matching lines @@
   Token get propertyKeyword => _propertyKeyword;
   /**
    * Return the return type of the function, or {@code null} if no return type was declared.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
   /**
    * Set the token representing the 'external' keyword to the given token.
    * @param externalKeyword the token representing the 'external' keyword
    */
-  void set externalKeyword(Token externalKeyword3) {
-    this._externalKeyword = externalKeyword3;
+  void set externalKeyword(Token externalKeyword2) {
+    this._externalKeyword = externalKeyword2;
   }
   /**
    * Set the function expression being wrapped to the given function expression.
    * @param functionExpression the function expression being wrapped
    */
-  void set functionExpression(FunctionExpression functionExpression3) {
-    functionExpression3 = becomeParentOf(functionExpression3);
+  void set functionExpression(FunctionExpression functionExpression2) {
+    functionExpression2 = becomeParentOf(functionExpression2);
   }
   /**
    * 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);
   }
   /**
    * Set the token representing the 'get' or 'set' keyword to the given token.
@@ skipping 141 matching lines @@
    * Set the body of the function to the given function body.
    * @param functionBody the body of the function
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
   /**
    * Set the element associated with this function to the given element.
    * @param element the element associated with this function
    */
-  void set element(ExecutableElement element9) {
-    this._element = element9;
+  void set element(ExecutableElement element2) {
+    this._element = element2;
   }
   /**
    * 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 parameters3) {
-    this._parameters = becomeParentOf(parameters3);
+  void set parameters(FormalParameterList parameters2) {
+    this._parameters = becomeParentOf(parameters2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionExpressionInvocation} represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by {@link MethodInvocation method invocation} nodes. Invocations of
@@ skipping 48 matching lines @@
   Token get endToken => _argumentList.endToken;
   /**
    * Return the expression producing the function being invoked.
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
   /**
    * 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 argumentList5) {
-    this._argumentList = becomeParentOf(argumentList5);
+  void set argumentList(ArgumentList argumentList2) {
+    this._argumentList = becomeParentOf(argumentList2);
   }
   /**
    * Set the element associated with the function being invoked to the given element.
    * @param element the element associated with the function being invoked
    */
-  void set element(ExecutableElement element10) {
-    this._element = element10;
+  void set element(ExecutableElement element2) {
+    this._element = element2;
   }
   /**
    * 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 visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_function, visitor);
@@ skipping 77 matching lines @@
   /**
    * Return the type parameters for the function type, or {@code null} if the function type does not
    * have any type parameters.
    * @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 name6) {
-    this._name = becomeParentOf(name6);
+  void set name(SimpleIdentifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * 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 parameters4) {
-    this._parameters = becomeParentOf(parameters4);
+  void set parameters(FormalParameterList parameters2) {
+    this._parameters = becomeParentOf(parameters2);
   }
   /**
    * 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 typeParameters4) {
-    this._typeParameters = becomeParentOf(typeParameters4);
+  void set typeParameters(TypeParameterList typeParameters2) {
+    this._typeParameters = becomeParentOf(typeParameters2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
@@ skipping 53 matching lines @@
    * type.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
   bool isConst() => false;
   bool 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 parameters5) {
-    this._parameters = becomeParentOf(parameters5);
+  void set parameters(FormalParameterList parameters2) {
+    this._parameters = becomeParentOf(parameters2);
   }
   /**
    * 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 visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 209 matching lines @@
    * Set the token representing the 'if' keyword to the given token.
    * @param ifKeyword the token representing the 'if' keyword
    */
   void set ifKeyword(Token ifKeyword2) {
     this._ifKeyword = ifKeyword2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis(Token leftParenthesis5) {
-    this._leftParenthesis = leftParenthesis5;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis(Token rightParenthesis5) {
-    this._rightParenthesis = rightParenthesis5;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   /**
    * Set the statement that is executed if the condition evaluates to {@code true} to the given
    * statement.
    * @param statement the statement that is executed if the condition evaluates to {@code true}
    */
   void set thenStatement(Statement statement) {
     _thenStatement = becomeParentOf(statement);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
@@ skipping 46 matching lines @@
   NodeList<TypeName> get interfaces => _interfaces;
   /**
    * Return the token representing the 'implements' keyword.
    * @return the token representing the 'implements' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the 'implements' keyword to the given token.
    * @param keyword the token representing the 'implements' keyword
    */
-  void set keyword(Token keyword12) {
-    this._keyword = keyword12;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _interfaces.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ImportDirective} represent an import directive.
  * <pre>
  * importDirective ::={@link Annotation metadata} 'import' {@link StringLiteral libraryUri} ('as' identifier)? {@link Combinator combinator}* ';'
  * </pre>
@@ skipping 104 matching lines @@
    * resolved or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * Initialize a newly created index expression.
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forTarget_full(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
-    _jtd_constructor_58_impl(target3, leftBracket4, index2, rightBracket4);
+  IndexExpression.forTarget_full(Expression target2, Token leftBracket2, Expression index2, Token rightBracket2) {
+    _jtd_constructor_58_impl(target2, leftBracket2, index2, rightBracket2);
   }
   /**
    * Initialize a newly created index expression.
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forTarget({Expression target3, Token leftBracket4, Expression index2, Token rightBracket4}) : this.forTarget_full(target3, leftBracket4, index2, rightBracket4);
-  _jtd_constructor_58_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
-    this._target = becomeParentOf(target3);
-    this._leftBracket = leftBracket4;
+  IndexExpression.forTarget({Expression target2, Token leftBracket2, Expression index2, Token rightBracket2}) : this.forTarget_full(target2, leftBracket2, index2, rightBracket2);
+  _jtd_constructor_58_impl(Expression target2, Token leftBracket2, Expression index2, Token rightBracket2) {
+    this._target = becomeParentOf(target2);
+    this._leftBracket = leftBracket2;
     this._index = becomeParentOf(index2);
-    this._rightBracket = rightBracket4;
+    this._rightBracket = rightBracket2;
   }
   /**
    * Initialize a newly created index expression.
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forCascade_full(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
-    _jtd_constructor_59_impl(period7, leftBracket5, index3, rightBracket5);
+  IndexExpression.forCascade_full(Token period2, Token leftBracket2, Expression index2, Token rightBracket2) {
+    _jtd_constructor_59_impl(period2, leftBracket2, index2, rightBracket2);
   }
   /**
    * Initialize a newly created index expression.
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forCascade({Token period7, Token leftBracket5, Expression index3, Token rightBracket5}) : this.forCascade_full(period7, leftBracket5, index3, rightBracket5);
-  _jtd_constructor_59_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
-    this._period = period7;
-    this._leftBracket = leftBracket5;
-    this._index = becomeParentOf(index3);
-    this._rightBracket = rightBracket5;
+  IndexExpression.forCascade({Token period2, Token leftBracket2, Expression index2, Token rightBracket2}) : this.forCascade_full(period2, leftBracket2, index2, rightBracket2);
+  _jtd_constructor_59_impl(Token period2, Token leftBracket2, Expression index2, Token rightBracket2) {
+    this._period = period2;
+    this._leftBracket = leftBracket2;
+    this._index = becomeParentOf(index2);
+    this._rightBracket = rightBracket2;
   }
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
   /**
    * Return the expression used to compute the object being indexed, or {@code null} if this index
    * expression is part of a cascade expression.
    * @return the expression used to compute the object being indexed
    * @see #getRealTarget()
    */
   Expression get array => _target;
   Token get beginToken {
@@ skipping 53 matching lines @@
    */
   Token get rightBracket => _rightBracket;
   /**
    * Return {@code true} if this expression is computing a right-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where the operator '[]' will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent4 = parent;
-    if (parent4 is AssignmentExpression) {
-      AssignmentExpression assignment = parent4 as AssignmentExpression;
+    ASTNode parent2 = parent;
+    if (parent2 is AssignmentExpression) {
+      AssignmentExpression assignment = parent2 as AssignmentExpression;
       if (identical(assignment.leftHandSide, this) && identical(assignment.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
   /**
    * Return {@code true} if this expression is computing a left-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where the operator '[]=' will be
    * invoked
    */
   bool inSetterContext() {
-    ASTNode parent5 = parent;
-    if (parent5 is PrefixExpression) {
-      return ((parent5 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent5 is PostfixExpression) {
+    ASTNode parent2 = parent;
+    if (parent2 is PrefixExpression) {
+      return ((parent2 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent2 is PostfixExpression) {
       return true;
-    } else if (parent5 is AssignmentExpression) {
-      return identical(((parent5 as AssignmentExpression)).leftHandSide, this);
+    } else if (parent2 is AssignmentExpression) {
+      return identical(((parent2 as AssignmentExpression)).leftHandSide, this);
     }
     return false;
   }
   bool isAssignable() => true;
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
   bool isCascaded() => _period != null;
   /**
    * Set the expression used to compute the object being indexed to the given expression.
    * @param expression the expression used to compute the object being indexed
    */
   void set array(Expression expression) {
     _target = becomeParentOf(expression);
   }
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with this operator
    */
-  void set element(MethodElement element11) {
-    this._element = element11;
+  void set element(MethodElement element2) {
+    this._element = element2;
   }
   /**
    * Set the expression used to compute the index to the given expression.
    * @param expression the expression used to compute the index
    */
   void set index(Expression expression) {
     _index = becomeParentOf(expression);
   }
   /**
    * Set the left square bracket to the given token.
    * @param bracket the left square bracket
    */
   void set leftBracket(Token bracket) {
     _leftBracket = bracket;
   }
   /**
    * Set the period ("..") before a cascaded index expression to the given token.
    * @param period the period ("..") before a cascaded index expression
    */
-  void set period(Token period8) {
-    this._period = period8;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * Set the right square bracket to the given token.
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
@@ skipping 70 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return {@code true} if this creation expression is used to invoke a constant constructor.
    * @return {@code true} if this creation expression is used to invoke a constant constructor
    */
   bool 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 argumentList6) {
-    this._argumentList = becomeParentOf(argumentList6);
+  void set argumentList(ArgumentList argumentList2) {
+    this._argumentList = becomeParentOf(argumentList2);
   }
   /**
    * Set the name of the constructor to be invoked to the given name.
    * @param constructorName the name of the constructor to be invoked
    */
-  void set constructorName(ConstructorName constructorName3) {
-    this._constructorName = constructorName3;
+  void set constructorName(ConstructorName constructorName2) {
+    this._constructorName = constructorName2;
   }
   /**
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
-  void set element(ConstructorElement element12) {
-    this._element = element12;
+  void set element(ConstructorElement element2) {
+    this._element = element2;
   }
   /**
    * Set the keyword used to indicate how an object should be created to the given keyword.
    * @param keyword the keyword used to indicate how an object should be created
    */
-  void set keyword(Token keyword13) {
-    this._keyword = keyword13;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code IntegerLiteral} represent an integer literal expression.
  * <pre>
  * integerLiteral ::=
@@ skipping 41 matching lines @@
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   int get value => _value;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal(Token literal4) {
-    this._literal = literal4;
+  void set literal(Token literal2) {
+    this._literal = literal2;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value(int value6) {
-    this._value = value6;
+  void set value(int value2) {
+    this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * The abstract class {@code InterpolationElement} defines the behavior common to elements within a{@link StringInterpolation string interpolation}.
  * <pre>
  * interpolationElement ::={@link InterpolationExpression interpolationExpression}| {@link InterpolationString interpolationString}</pre>
  * @coverage dart.engine.ast
  */
@@ skipping 61 matching lines @@
   /**
    * Return the right curly bracket.
    * @return the right curly bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * 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 expression6) {
-    this._expression = becomeParentOf(expression6);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket(Token leftBracket6) {
-    this._leftBracket = leftBracket6;
+  void set leftBracket(Token leftBracket2) {
+    this._leftBracket = leftBracket2;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket(Token rightBracket6) {
-    this._rightBracket = rightBracket6;
+  void set rightBracket(Token rightBracket2) {
+    this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code InterpolationString} represent a non-empty substring of an
  * interpolated string.
  * <pre>
  * interpolationString ::=
@@ skipping 120 matching lines @@
   /**
    * Return the name of the type being tested for.
    * @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 expression7) {
-    this._expression = becomeParentOf(expression7);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the is operator being applied to the given operator.
    * @param isOperator the is operator being applied
    */
   void set isOperator(Token isOperator2) {
     this._isOperator = isOperator2;
   }
   /**
    * Set the not operator being applied to the given operator.
@@ skipping 55 matching lines @@
   Token get endToken => _colon;
   /**
    * Return the label being associated with the statement.
    * @return the label being associated with the statement
    */
   SimpleIdentifier get label => _label;
   /**
    * Set the colon that separates the label from the statement to the given token.
    * @param colon the colon that separates the label from the statement
    */
-  void set colon(Token colon3) {
-    this._colon = colon3;
+  void set colon(Token colon2) {
+    this._colon = colon2;
   }
   /**
    * 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 label3) {
-    this._label = becomeParentOf(label3);
+  void set label(SimpleIdentifier label2) {
+    this._label = becomeParentOf(label2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class {@code LabeledStatement} represent a statement that has a label associated
  * with them.
  * <pre>
  * labeledStatement ::={@link Label label}+ {@link Statement statement}</pre>
@@ skipping 118 matching lines @@
    * Set the token representing the 'library' token to the given token.
    * @param libraryToken the token representing the 'library' token
    */
   void set libraryToken(Token libraryToken2) {
     this._libraryToken = libraryToken2;
   }
   /**
    * 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 name7) {
-    this._name = becomeParentOf(name7);
+  void set name(LibraryIdentifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon(Token semicolon11) {
-    this._semicolon = semicolon11;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _libraryToken;
 }
 /**
  * Instances of the class {@code LibraryIdentifier} represent the identifier for a library.
  * <pre>
@@ skipping 90 matching lines @@
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral({Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, elements, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
       return token;
     }
-    TypeArgumentList typeArguments6 = typeArguments;
-    if (typeArguments6 != null) {
-      return typeArguments6.beginToken;
+    TypeArgumentList typeArguments2 = typeArguments;
+    if (typeArguments2 != null) {
+      return typeArguments2.beginToken;
     }
     return _leftBracket;
   }
   /**
    * Return the expressions used to compute the elements of the list.
    * @return the expressions used to compute the elements of the list
    */
   NodeList<Expression> get elements => _elements;
   Token get endToken => _rightBracket;
   /**
@@ skipping 79 matching lines @@
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral({Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, entries, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
       return token;
     }
-    TypeArgumentList typeArguments7 = typeArguments;
-    if (typeArguments7 != null) {
-      return typeArguments7.beginToken;
+    TypeArgumentList typeArguments2 = typeArguments;
+    if (typeArguments2 != null) {
+      return typeArguments2.beginToken;
     }
     return _leftBracket;
   }
   Token get endToken => _rightBracket;
   /**
    * Return the entries in the map.
    * @return the entries in the map
    */
   NodeList<MapLiteralEntry> get entries => _entries;
   /**
@@ skipping 85 matching lines @@
    * Set the key with which the value will be associated to the given string.
    * @param string the key with which the value will be associated
    */
   void set key(StringLiteral string) {
     _key = becomeParentOf(string);
   }
   /**
    * Set the colon that separates the key from the value to the given token.
    * @param separator the colon that separates the key from the value
    */
-  void set separator(Token separator4) {
-    this._separator = separator4;
+  void set separator(Token separator2) {
+    this._separator = separator2;
   }
   /**
    * Set the expression computing the value that will be associated with the key to the given
    * expression.
    * @param expression the expression computing the value that will be associated with the key
    */
   void set value(Expression expression) {
     _value = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
@@ skipping 168 matching lines @@
    * Set the body of the method to the given function body.
    * @param functionBody the body of the method
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
   /**
    * Set the token for the 'external' keyword to the given token.
    * @param externalKeyword the token for the 'external' keyword
    */
-  void set externalKeyword(Token externalKeyword4) {
-    this._externalKeyword = externalKeyword4;
+  void set externalKeyword(Token externalKeyword2) {
+    this._externalKeyword = externalKeyword2;
   }
   /**
    * Set the token representing the 'abstract' or 'static' keyword to the given token.
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    */
   void set modifierKeyword(Token modifierKeyword2) {
     this._modifierKeyword = modifierKeyword2;
   }
   /**
    * Set the name of the method to the given identifier.
    * @param identifier the name of the method
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the token representing the 'operator' keyword to the given token.
    * @param operatorKeyword the token representing the 'operator' keyword
    */
   void set operatorKeyword(Token operatorKeyword2) {
     this._operatorKeyword = operatorKeyword2;
   }
   /**
    * 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 parameters6) {
-    this._parameters = becomeParentOf(parameters6);
+  void set parameters(FormalParameterList parameters2) {
+    this._parameters = becomeParentOf(parameters2);
   }
   /**
    * Set the token representing the 'get' or 'set' keyword to the given token.
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    */
-  void set propertyKeyword(Token propertyKeyword3) {
-    this._propertyKeyword = propertyKeyword3;
+  void set propertyKeyword(Token propertyKeyword2) {
+    this._propertyKeyword = propertyKeyword2;
   }
   /**
    * 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);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 122 matching lines @@
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
   bool 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 argumentList7) {
-    this._argumentList = becomeParentOf(argumentList7);
+  void set argumentList(ArgumentList argumentList2) {
+    this._argumentList = becomeParentOf(argumentList2);
   }
   /**
    * 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);
   }
   /**
    * Set the period that separates the target from the method name to the given token.
    * @param period the period that separates the target from the method name
    */
-  void set period(Token period9) {
-    this._period = period9;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * Set the expression producing the object on which the method is defined to the given expression.
    * @param expression the expression producing the object on which the method is defined
    */
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
@@ skipping 33 matching lines @@
    */
   NamedExpression({Label name, Expression expression}) : this.full(name, expression);
   accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
   Token get beginToken => _name.beginToken;
   /**
    * Return the element representing the parameter being named by this expression, or {@code null}if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    * @return the element representing the parameter being named by this expression
    */
   ParameterElement get element {
-    Element element22 = _name.label.element;
-    if (element22 is ParameterElement) {
-      return element22 as ParameterElement;
+    Element element2 = _name.label.element;
+    if (element2 is ParameterElement) {
+      return element2 as ParameterElement;
     }
     return null;
   }
   Token get endToken => _expression.endToken;
   /**
    * Return the expression with which the name is associated.
    * @return the expression with which the name is associated
    */
   Expression get expression => _expression;
   /**
    * Return the name associated with the expression.
    * @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 expression8) {
-    this._expression = becomeParentOf(expression8);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * 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);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
@@ skipping 61 matching lines @@
    * Set the token representing the 'import' or 'export' keyword to the given token.
    * @param exportToken the token representing the 'import' or 'export' keyword
    */
   void set keyword(Token exportToken) {
     this._keyword = exportToken;
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon(Token semicolon12) {
-    this._semicolon = semicolon12;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * Instances of the class {@code NativeFunctionBody} represent a function body that consists of a
  * native keyword followed by a string literal.
  * <pre>
  * nativeFunctionBody ::=
  * 'native' {@link SimpleStringLiteral simpleStringLiteral} ';'
  * </pre>
@@ skipping 95 matching lines @@
    */
   NormalFormalParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier identifier}) : this.full(comment, metadata, identifier);
   /**
    * Return the documentation comment associated with this parameter, or {@code null} if this
    * parameter does not have a documentation comment associated with it.
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
   SimpleIdentifier get identifier => _identifier;
   ParameterKind get kind {
-    ASTNode parent6 = parent;
-    if (parent6 is DefaultFormalParameter) {
-      return ((parent6 as DefaultFormalParameter)).kind;
+    ASTNode parent2 = parent;
+    if (parent2 is DefaultFormalParameter) {
+      return ((parent2 as DefaultFormalParameter)).kind;
     }
     return ParameterKind.REQUIRED;
   }
   /**
    * Return the annotations associated with this parameter.
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
   /**
    * Return {@code true} if this parameter was declared with the 'const' modifier.
    * @return {@code true} if this parameter was declared with the 'const' modifier
    */
   bool isConst();
   /**
    * Return {@code true} if this parameter was declared with the 'final' modifier. Parameters that
    * are declared with the 'const' modifier will return {@code false} even though they are
    * implicitly final.
    * @return {@code true} if this parameter was declared with the 'final' modifier
    */
   bool isFinal();
   /**
    * 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 comment3) {
-    this._comment = becomeParentOf(comment3);
+  void set documentationComment(Comment comment2) {
+    this._comment = becomeParentOf(comment2);
   }
   /**
    * 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 identifier9) {
-    this._identifier = becomeParentOf(identifier9);
+  void set identifier(SimpleIdentifier identifier2) {
+    this._identifier = becomeParentOf(identifier2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 54 matching lines @@
   Token get endToken => _literal;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal(Token literal5) {
-    this._literal = literal5;
+  void set literal(Token literal2) {
+    this._literal = literal2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ParenthesizedExpression} represent a parenthesized expression.
  * <pre>
  * parenthesizedExpression ::=
  * '(' {@link Expression expression} ')'
  * </pre>
@@ skipping 45 matching lines @@
   Token get leftParenthesis => _leftParenthesis;
   /**
    * Return the right parenthesis.
    * @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 expression9) {
-    this._expression = becomeParentOf(expression9);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
   void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the right parenthesis to the given token.
@@ skipping 60 matching lines @@
    * Set the token representing the 'part' token to the given token.
    * @param partToken the token representing the 'part' token
    */
   void set partToken(Token partToken2) {
     this._partToken = partToken2;
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon(Token semicolon13) {
-    this._semicolon = semicolon13;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PartOfDirective} represent a part-of directive.
  * <pre>
  * partOfDirective ::={@link Annotation metadata} 'part' 'of' {@link Identifier libraryName} ';'
  * </pre>
  * @coverage dart.engine.ast
  */
@@ skipping 73 matching lines @@
    * Set the token representing the 'of' token to the given token.
    * @param ofToken the token representing the 'of' token
    */
   void set ofToken(Token ofToken2) {
     this._ofToken = ofToken2;
   }
   /**
    * Set the token representing the 'part' token to the given token.
    * @param partToken the token representing the 'part' token
    */
-  void set partToken(Token partToken3) {
-    this._partToken = partToken3;
+  void set partToken(Token partToken2) {
+    this._partToken = partToken2;
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon(Token semicolon14) {
-    this._semicolon = semicolon14;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PostfixExpression} represent a postfix unary expression.
  * <pre>
@@ skipping 46 matching lines @@
   Expression get operand => _operand;
   /**
    * Return the postfix operator being applied to the operand.
    * @return the postfix operator being applied to the operand
    */
   Token get operator => _operator;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element(MethodElement element13) {
-    this._element = element13;
+  void set element(MethodElement element2) {
+    this._element = element2;
   }
   /**
    * Set the expression computing the operand for the operator to the given expression.
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
   /**
    * Set the postfix operator being applied to the operand to the given operator.
    * @param operator the postfix operator being applied to the operand
    */
-  void set operator(Token operator4) {
-    this._operator = operator4;
+  void set operator(Token operator2) {
+    this._operator = operator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
  * <pre>
  * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
  * @coverage dart.engine.ast
@@ skipping 44 matching lines @@
   Expression get operand => _operand;
   /**
    * Return the prefix operator being applied to the operand.
    * @return the prefix operator being applied to the operand
    */
   Token get operator => _operator;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element(MethodElement element14) {
-    this._element = element14;
+  void set element(MethodElement element2) {
+    this._element = element2;
   }
   /**
    * Set the expression computing the operand for the operator to the given expression.
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
   /**
    * Set the prefix operator being applied to the operand to the given operator.
    * @param operator the prefix operator being applied to the operand
    */
-  void set operator(Token operator5) {
-    this._operator = operator5;
+  void set operator(Token operator2) {
+    this._operator = operator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixedIdentifier} represent either an identifier that is prefixed
  * or an access to an object property where the target of the property access is a simple
  * identifier.
  * <pre>
@@ skipping 53 matching lines @@
   Token get period => _period;
   /**
    * Return the prefix associated with the library in which the identifier is defined.
    * @return the prefix associated with the library in which the identifier is defined
    */
   SimpleIdentifier get prefix => _prefix;
   /**
    * Set the identifier being prefixed to the given identifier.
    * @param identifier the identifier being prefixed
    */
-  void set identifier(SimpleIdentifier identifier10) {
-    this._identifier = becomeParentOf(identifier10);
+  void set identifier(SimpleIdentifier identifier2) {
+    this._identifier = becomeParentOf(identifier2);
   }
   /**
    * Set the period used to separate the prefix from the identifier to the given token.
    * @param period the period used to separate the prefix from the identifier
    */
-  void set period(Token period10) {
-    this._period = period10;
+  void set period(Token period2) {
+    this._period = period2;
   }
   /**
    * 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);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
@@ skipping 90 matching lines @@
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
   bool isCascaded() => _operator != null && identical(_operator.type, TokenType.PERIOD_PERIOD);
   /**
    * Set the property access operator to the given token.
    * @param operator the property access operator
    */
-  void set operator(Token operator6) {
-    this._operator = operator6;
+  void set operator(Token operator2) {
+    this._operator = operator2;
   }
   /**
    * Set the name of the property being accessed to the given identifier.
    * @param identifier the name of the property being accessed
    */
   void set propertyName(SimpleIdentifier identifier) {
     _propertyName = becomeParentOf(identifier);
   }
   /**
    * Set the expression computing the object defining the property being accessed to the given
@@ skipping 90 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
   /**
    * 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 argumentList8) {
-    this._argumentList = becomeParentOf(argumentList8);
+  void set argumentList(ArgumentList argumentList2) {
+    this._argumentList = becomeParentOf(argumentList2);
   }
   /**
    * 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);
   }
   /**
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
-  void set element(ConstructorElement element15) {
-    this._element = element15;
+  void set element(ConstructorElement element2) {
+    this._element = element2;
   }
   /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
-  void set keyword(Token keyword14) {
-    this._keyword = keyword14;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
-  void set period(Token period11) {
-    this._period = period11;
+  void set period(Token period2) {
+    this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code RethrowExpression} represent a rethrow expression.
  * <pre>
  * rethrowExpression ::=
@@ skipping 23 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the 'rethrow' keyword.
    * @return the token representing the 'rethrow' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the 'rethrow' keyword to the given token.
    * @param keyword the token representing the 'rethrow' keyword
    */
-  void set keyword(Token keyword15) {
-    this._keyword = keyword15;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ReturnStatement} represent a return statement.
  * <pre>
  * returnStatement ::=
  * 'return' {@link Expression expression}? ';'
  * </pre>
@@ skipping 47 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * 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 expression10) {
-    this._expression = becomeParentOf(expression10);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the token representing the 'return' keyword to the given token.
    * @param keyword the token representing the 'return' keyword
    */
-  void set keyword(Token keyword16) {
-    this._keyword = keyword16;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon15) {
-    this._semicolon = semicolon15;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ScriptTag} represent the script tag that can optionally occur at
  * the beginning of a compilation unit.
  * <pre>
  * scriptTag ::=
@@ skipping 23 matching lines @@
   Token get endToken => _scriptTag;
   /**
    * Return the token representing this script tag.
    * @return the token representing this script tag
    */
   Token get scriptTag => _scriptTag;
   /**
    * Set the token representing this script tag to the given script tag.
    * @param scriptTag the token representing this script tag
    */
-  void set scriptTag(Token scriptTag3) {
-    this._scriptTag = scriptTag3;
+  void set scriptTag(Token scriptTag2) {
+    this._scriptTag = scriptTag2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ShowCombinator} represent a combinator that restricts the names
  * being imported to those in a given list.
  * <pre>
  * showCombinator ::=
  * 'show' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
@@ skipping 90 matching lines @@
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword17) {
-    this._keyword = keyword17;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * 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);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 41 matching lines @@
   /**
    * Return the token representing the identifier.
    * @return the token representing the identifier
    */
   Token get token => _token;
   /**
    * Return {@code true} if this identifier is the name being declared in a declaration.
    * @return {@code true} if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
-    ASTNode parent7 = parent;
-    if (parent7 is CatchClause) {
-      CatchClause clause = parent7 as CatchClause;
+    ASTNode parent2 = parent;
+    if (parent2 is CatchClause) {
+      CatchClause clause = parent2 as CatchClause;
       return identical(this, clause.exceptionParameter) || identical(this, clause.stackTraceParameter);
-    } else if (parent7 is ClassDeclaration) {
-      return identical(this, ((parent7 as ClassDeclaration)).name);
-    } else if (parent7 is ClassTypeAlias) {
-      return identical(this, ((parent7 as ClassTypeAlias)).name);
-    } else if (parent7 is ConstructorDeclaration) {
-      return identical(this, ((parent7 as ConstructorDeclaration)).name);
-    } else if (parent7 is FunctionDeclaration) {
-      return identical(this, ((parent7 as FunctionDeclaration)).name);
-    } else if (parent7 is FunctionTypeAlias) {
-      return identical(this, ((parent7 as FunctionTypeAlias)).name);
-    } else if (parent7 is Label) {
-      return identical(this, ((parent7 as Label)).label) && (parent7.parent is LabeledStatement);
-    } else if (parent7 is MethodDeclaration) {
-      return identical(this, ((parent7 as MethodDeclaration)).name);
-    } else if (parent7 is FunctionTypedFormalParameter || parent7 is SimpleFormalParameter) {
-      return identical(this, ((parent7 as NormalFormalParameter)).identifier);
-    } else if (parent7 is TypeParameter) {
-      return identical(this, ((parent7 as TypeParameter)).name);
-    } else if (parent7 is VariableDeclaration) {
-      return identical(this, ((parent7 as VariableDeclaration)).name);
+    } else if (parent2 is ClassDeclaration) {
+      return identical(this, ((parent2 as ClassDeclaration)).name);
+    } else if (parent2 is ClassTypeAlias) {
+      return identical(this, ((parent2 as ClassTypeAlias)).name);
+    } else if (parent2 is ConstructorDeclaration) {
+      return identical(this, ((parent2 as ConstructorDeclaration)).name);
+    } else if (parent2 is FunctionDeclaration) {
+      return identical(this, ((parent2 as FunctionDeclaration)).name);
+    } else if (parent2 is FunctionTypeAlias) {
+      return identical(this, ((parent2 as FunctionTypeAlias)).name);
+    } else if (parent2 is Label) {
+      return identical(this, ((parent2 as Label)).label) && (parent2.parent is LabeledStatement);
+    } else if (parent2 is MethodDeclaration) {
+      return identical(this, ((parent2 as MethodDeclaration)).name);
+    } else if (parent2 is FunctionTypedFormalParameter || parent2 is SimpleFormalParameter) {
+      return identical(this, ((parent2 as NormalFormalParameter)).identifier);
+    } else if (parent2 is TypeParameter) {
+      return identical(this, ((parent2 as TypeParameter)).name);
+    } else if (parent2 is VariableDeclaration) {
+      return identical(this, ((parent2 as VariableDeclaration)).name);
     }
     return false;
   }
   /**
    * Return {@code true} if this expression is computing a right-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where a getter will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent8 = parent;
+    ASTNode parent2 = parent;
     ASTNode target = this;
-    if (parent8 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent8 as PrefixedIdentifier;
+    if (parent2 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent2 as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
-      parent8 = prefixed.parent;
+      parent2 = prefixed.parent;
       target = prefixed;
-    } else if (parent8 is PropertyAccess) {
-      PropertyAccess access = parent8 as PropertyAccess;
+    } else if (parent2 is PropertyAccess) {
+      PropertyAccess access = parent2 as PropertyAccess;
       if (identical(access.target, this)) {
         return true;
       }
-      parent8 = access.parent;
+      parent2 = access.parent;
       target = access;
     }
-    if (parent8 is Label) {
+    if (parent2 is Label) {
       return false;
     }
-    if (parent8 is AssignmentExpression) {
-      AssignmentExpression expr = parent8 as AssignmentExpression;
+    if (parent2 is AssignmentExpression) {
+      AssignmentExpression expr = parent2 as AssignmentExpression;
       if (identical(expr.leftHandSide, target) && identical(expr.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
   /**
    * Return {@code true} if this expression is computing a left-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where a setter will be invoked
    */
   bool inSetterContext() {
-    ASTNode parent9 = parent;
+    ASTNode parent2 = parent;
     ASTNode target = this;
-    if (parent9 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent9 as PrefixedIdentifier;
+    if (parent2 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent2 as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return false;
       }
-      parent9 = prefixed.parent;
+      parent2 = prefixed.parent;
       target = prefixed;
-    } else if (parent9 is PropertyAccess) {
-      PropertyAccess access = parent9 as PropertyAccess;
+    } else if (parent2 is PropertyAccess) {
+      PropertyAccess access = parent2 as PropertyAccess;
       if (identical(access.target, this)) {
         return false;
       }
-      parent9 = access.parent;
+      parent2 = access.parent;
       target = access;
     }
-    if (parent9 is PrefixExpression) {
-      return ((parent9 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent9 is PostfixExpression) {
+    if (parent2 is PrefixExpression) {
+      return ((parent2 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent2 is PostfixExpression) {
       return true;
-    } else if (parent9 is AssignmentExpression) {
-      return identical(((parent9 as AssignmentExpression)).leftHandSide, target);
+    } else if (parent2 is AssignmentExpression) {
+      return identical(((parent2 as AssignmentExpression)).leftHandSide, target);
     }
     return false;
   }
   bool isSynthetic() => _token.isSynthetic();
   /**
    * Set the element associated with this identifier to the given element.
    * @param element the element associated with this identifier
    */
-  void set element(Element element16) {
-    this._element = element16;
+  void set element(Element element2) {
+    this._element = element2;
   }
   /**
    * Set the token representing the identifier to the given token.
    * @param token the token representing the literal
    */
-  void set token(Token token17) {
-    this._token = token17;
+  void set token(Token token2) {
+    this._token = token2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SimpleStringLiteral} represent a string literal expression that
  * does not contain any interpolations.
  * <pre>
  * simpleStringLiteral ::=
  * rawStringLiteral
@@ skipping 62 matching lines @@
   /**
    * Return {@code true} if this string literal is a raw string.
    * @return {@code true} if this string literal is a raw string
    */
   bool isRaw() => _value.codeUnitAt(0) == 0x40;
   bool isSynthetic() => _literal.isSynthetic();
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal(Token literal6) {
-    this._literal = literal6;
+  void set literal(Token literal2) {
+    this._literal = literal2;
   }
   /**
    * Set the value of the literal to the given string.
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
@@ skipping 135 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
   /**
    * 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 argumentList9) {
-    this._argumentList = becomeParentOf(argumentList9);
+  void set argumentList(ArgumentList argumentList2) {
+    this._argumentList = becomeParentOf(argumentList2);
   }
   /**
    * 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);
   }
   /**
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
-  void set element(ConstructorElement element17) {
-    this._element = element17;
+  void set element(ConstructorElement element2) {
+    this._element = element2;
   }
   /**
    * Set the token for the 'super' keyword to the given token.
    * @param keyword the token for the 'super' keyword
    */
-  void set keyword(Token keyword18) {
-    this._keyword = keyword18;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
-  void set period(Token period12) {
-    this._period = period12;
+  void set period(Token period2) {
+    this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code SuperExpression} represent a super expression.
  * <pre>
  * superExpression ::=
@@ skipping 23 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword19) {
-    this._keyword = keyword19;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SwitchCase} represent the case in a switch statement.
  * <pre>
  * switchCase ::={@link SimpleIdentifier label}* 'case' {@link Expression expression} ':' {@link Statement statement}</pre>
  * @coverage dart.engine.ast
  */
@@ skipping 25 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitSwitchCase(this);
   /**
    * Return the expression controlling whether the statements will be executed.
    * @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 expression11) {
-    this._expression = becomeParentOf(expression11);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code SwitchDefault} represent the default case in a switch statement.
  * <pre>
@@ skipping 103 matching lines @@
   NodeList<Label> get labels => _labels;
   /**
    * Return the statements that will be executed if this switch member is selected.
    * @return the statements that will be executed if this switch member is selected
    */
   NodeList<Statement> get statements => _statements;
   /**
    * Set the colon separating the keyword or the expression from the statements to the given token.
    * @param colon the colon separating the keyword or the expression from the statements
    */
-  void set colon(Token colon4) {
-    this._colon = colon4;
+  void set colon(Token colon2) {
+    this._colon = colon2;
   }
   /**
    * Set the token representing the 'case' or 'default' keyword to the given token.
    * @param keyword the token representing the 'case' or 'default' keyword
    */
-  void set keyword(Token keyword20) {
-    this._keyword = keyword20;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
 }
 /**
  * Instances of the class {@code SwitchStatement} represent a switch statement.
  * <pre>
  * switchStatement ::=
  * 'switch' '(' {@link Expression expression} ')' '{' {@link SwitchCase switchCase}* {@link SwitchDefault defaultCase}? '}'
  * </pre>
  * @coverage dart.engine.ast
  */
@@ skipping 93 matching lines @@
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * 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 expression12) {
-    this._expression = becomeParentOf(expression12);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the token representing the 'switch' keyword to the given token.
    * @param keyword the token representing the 'switch' keyword
    */
-  void set keyword(Token keyword21) {
-    this._keyword = keyword21;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket(Token leftBracket7) {
-    this._leftBracket = leftBracket7;
+  void set leftBracket(Token leftBracket2) {
+    this._leftBracket = leftBracket2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis(Token leftParenthesis6) {
-    this._leftParenthesis = leftParenthesis6;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket(Token rightBracket7) {
-    this._rightBracket = rightBracket7;
+  void set rightBracket(Token rightBracket2) {
+    this._rightBracket = rightBracket2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis(Token rightParenthesis6) {
-    this._rightParenthesis = rightParenthesis6;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ThisExpression} represent a this expression.
  * <pre>
  * thisExpression ::=
@@ skipping 23 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword22) {
-    this._keyword = keyword22;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ThrowExpression} represent a throw expression.
  * <pre>
  * throwExpression ::=
  * 'throw' {@link Expression expression}</pre>
  * @coverage dart.engine.ast
@@ skipping 37 matching lines @@
   Expression get expression => _expression;
   /**
    * Return the token representing the 'throw' keyword.
    * @return the token representing the 'throw' keyword
    */
   Token get keyword => _keyword;
   /**
    * 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 expression13) {
-    this._expression = becomeParentOf(expression13);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the token representing the 'throw' keyword to the given token.
    * @param keyword the token representing the 'throw' keyword
    */
-  void set keyword(Token keyword23) {
-    this._keyword = keyword23;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code TopLevelVariableDeclaration} represent the declaration of one or
  * more top-level variables of the same type.
  * <pre>
  * topLevelVariableDeclaration ::=
@@ skipping 40 matching lines @@
   Token get semicolon => _semicolon;
   /**
    * Return the top-level variables being declared.
    * @return the top-level variables being declared
    */
   VariableDeclarationList get variables => _variableList;
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon(Token semicolon16) {
-    this._semicolon = semicolon16;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   /**
    * Set the top-level variables being declared to the given list of variables.
    * @param variableList the top-level variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 178 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'typedef' keyword to the given token.
    * @param keyword the token representing the 'typedef' keyword
    */
-  void set keyword(Token keyword24) {
-    this._keyword = keyword24;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon(Token semicolon17) {
-    this._semicolon = semicolon17;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * Instances of the class {@code TypeArgumentList} represent a list of type arguments.
  * <pre>
  * typeArguments ::=
  * '<' typeName (',' typeName)* '>'
  * </pre>
  * @coverage dart.engine.ast
@@ skipping 45 matching lines @@
   Token get leftBracket => _leftBracket;
   /**
    * Return the right bracket.
    * @return the right bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Set the left bracket to the given token.
    * @param leftBracket the left bracket
    */
-  void set leftBracket(Token leftBracket8) {
-    this._leftBracket = leftBracket8;
+  void set leftBracket(Token leftBracket2) {
+    this._leftBracket = leftBracket2;
   }
   /**
    * Set the right bracket to the given token.
    * @param rightBracket the right bracket
    */
-  void set rightBracket(Token rightBracket8) {
-    this._rightBracket = rightBracket8;
+  void set rightBracket(Token rightBracket2) {
+    this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code TypeName} represent the name of a type, which can optionally
  * include type arguments.
  * <pre>
  * typeName ::={@link Identifier identifier} typeArguments?
@@ skipping 59 matching lines @@
    * Set the name of the type to the given identifier.
    * @param identifier the name of the type
    */
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the type being named to the given type.
    * @param type the type being named
    */
-  void set type(Type2 type3) {
-    this._type = type3;
+  void set type(Type2 type2) {
+    this._type = type2;
   }
   /**
    * 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 visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
@@ skipping 72 matching lines @@
    * Set the name of the upper bound for legal arguments to the given type name.
    * @param typeName the name of the upper bound for legal arguments
    */
   void set bound(TypeName typeName) {
     _bound = becomeParentOf(typeName);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword(Token keyword25) {
-    this._keyword = keyword25;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the name of the type parameter to the given identifier.
    * @param identifier the name of the type parameter
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 114 matching lines @@
    * Set the modifiers associated with this literal to the given modifiers.
    * @param modifiers the modifiers associated with this literal
    */
   void set modifier(Token modifier2) {
     this._modifier = modifier2;
   }
   /**
    * Set the type argument associated with this literal to the given arguments.
    * @param typeArguments the type argument associated with this literal
    */
-  void set typeArguments(TypeArgumentList typeArguments3) {
-    this._typeArguments = typeArguments3;
+  void set typeArguments(TypeArgumentList typeArguments2) {
+    this._typeArguments = typeArguments2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * The abstract class {@code UriBasedDirective} defines the behavior common to nodes that represent
  * a directive that references a URI.
  * <pre>
  * uriBasedDirective ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link PartDirective partDirective}</pre>
@@ skipping 105 matching lines @@
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
   /**
    * Return {@code true} if this variable was declared with the 'const' modifier.
    * @return {@code true} if this variable was declared with the 'const' modifier
    */
   bool isConst() {
-    ASTNode parent10 = parent;
-    return parent10 is VariableDeclarationList && ((parent10 as VariableDeclarationList)).isConst();
+    ASTNode parent2 = parent;
+    return parent2 is VariableDeclarationList && ((parent2 as VariableDeclarationList)).isConst();
   }
   /**
    * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return {@code false} even though they are implicitly
    * final.
    * @return {@code true} if this variable was declared with the 'final' modifier
    */
   bool isFinal() {
-    ASTNode parent11 = parent;
-    return parent11 is VariableDeclarationList && ((parent11 as VariableDeclarationList)).isFinal();
+    ASTNode parent2 = parent;
+    return parent2 is VariableDeclarationList && ((parent2 as VariableDeclarationList)).isFinal();
   }
   /**
    * Set the equal sign separating the variable name from the initial value to the given token.
    * @param equals the equal sign separating the variable name from the initial value
    */
-  void set equals(Token equals6) {
-    this._equals = equals6;
+  void set equals(Token equals2) {
+    this._equals = equals2;
   }
   /**
    * 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);
   }
   /**
    * 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 name8) {
-    this._name = becomeParentOf(name8);
+  void set name(SimpleIdentifier name2) {
+    this._name = becomeParentOf(name2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class {@code VariableDeclarationList} represent the declaration of one or more
@@ skipping 72 matching lines @@
    * Return {@code true} if the variables in this list were declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return {@code false} even though
    * they are implicitly final.
    * @return {@code true} if the variables in this list were declared with the 'final' modifier
    */
   bool isFinal() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword26) {
-    this._keyword = keyword26;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the type of the variables being declared to the given type name.
    * @param typeName the type of the variables being declared
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
@@ skipping 50 matching lines @@
   Token get semicolon => _semicolon;
   /**
    * Return the variables being declared.
    * @return the variables being declared
    */
   VariableDeclarationList get variables => _variableList;
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon(Token semicolon18) {
-    this._semicolon = semicolon18;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   /**
    * 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 visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
@@ skipping 91 matching lines @@
    * expression.
    * @param expression the expression used to determine whether to execute the body of the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param keyword the token representing the 'while' keyword
    */
-  void set keyword(Token keyword27) {
-    this._keyword = keyword27;
+  void set keyword(Token keyword2) {
+    this._keyword = keyword2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis(Token leftParenthesis7) {
-    this._leftParenthesis = leftParenthesis7;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis(Token rightParenthesis7) {
-    this._rightParenthesis = rightParenthesis7;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code WithClause} represent the with clause in a class declaration.
  * <pre>
  * withClause ::=
@@ skipping 254 matching lines @@
         return value;
       }
       list.add(value);
     }
     return list;
   }
   Object visitMapLiteral(MapLiteral node) {
     Map<String, Object> map = new Map<String, Object>();
     for (MapLiteralEntry entry in node.entries) {
       Object key2 = entry.key.accept(this);
-      Object value8 = entry.value.accept(this);
-      if (key2 is! String || identical(value8, NOT_A_CONSTANT)) {
+      Object value2 = entry.value.accept(this);
+      if (key2 is! String || identical(value2, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
-      map[(key2 as String)] = value8;
+      map[(key2 as String)] = value2;
     }
     return map;
   }
   Object visitMethodInvocation(MethodInvocation node) => visitNode(node);
   Object visitNode(ASTNode node) => NOT_A_CONSTANT;
   Object visitNullLiteral(NullLiteral node) => null;
   Object visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
   Object visitPrefixedIdentifier(PrefixedIdentifier node) => getConstantValue(null);
   Object visitPrefixExpression(PrefixExpression node) {
     Object operand2 = node.operand.accept(this);
@@ skipping 86 matching lines @@
   Element visitImportDirective(ImportDirective node) => node.element;
   Element visitIndexExpression(IndexExpression node) => node.element;
   Element visitInstanceCreationExpression(InstanceCreationExpression node) => node.element;
   Element visitLibraryDirective(LibraryDirective node) => node.element;
   Element visitMethodDeclaration(MethodDeclaration node) => node.element;
   Element visitMethodInvocation(MethodInvocation node) => node.methodName.element;
   Element visitPostfixExpression(PostfixExpression node) => node.element;
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.element;
   Element visitPrefixExpression(PrefixExpression node) => node.element;
   Element visitStringLiteral(StringLiteral node) {
-    ASTNode parent12 = node.parent;
-    if (parent12 is UriBasedDirective) {
-      return ((parent12 as UriBasedDirective)).element;
+    ASTNode parent2 = node.parent;
+    if (parent2 is UriBasedDirective) {
+      return ((parent2 as UriBasedDirective)).element;
     }
     return null;
   }
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 /**
  * Instances of the class {@code GeneralizingASTVisitor} implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class{@link RecursiveASTVisitor}). In addition, when a node of a specific type is visited not only
  * will the visit method for that specific type of node be invoked, but additional methods for the
  * superclasses of that node will also be invoked. For example, using an instance of this class to
@@ skipping 893 matching lines @@
     }
     visit(node.superclass);
     visit3(" ", node.withClause);
     visit3(" ", node.implementsClause);
     _writer.print(";");
     return null;
   }
   Object visitComment(Comment node) => null;
   Object visitCommentReference(CommentReference node) => null;
   Object visitCompilationUnit(CompilationUnit node) {
-    ScriptTag scriptTag6 = node.scriptTag;
+    ScriptTag scriptTag2 = node.scriptTag;
     NodeList<Directive> directives2 = node.directives;
-    visit(scriptTag6);
-    String prefix = scriptTag6 == null ? "" : " ";
+    visit(scriptTag2);
+    String prefix = scriptTag2 == null ? "" : " ";
     visitList4(prefix, directives2, " ");
-    prefix = scriptTag6 == null && directives2.isEmpty ? "" : " ";
+    prefix = scriptTag2 == null && directives2.isEmpty ? "" : " ";
     visitList4(prefix, node.declarations, " ");
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
     _writer.print(" ? ");
     visit(node.thenExpression);
     _writer.print(" : ");
     visit(node.elseExpression);
     return null;
@@ skipping 106 matching lines @@
     visit(node.loopVariable);
     _writer.print(" in ");
     visit(node.iterator);
     _writer.print(") ");
     visit(node.body);
     return null;
   }
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
-    NodeList<FormalParameter> parameters10 = node.parameters;
-    int size2 = parameters10.length;
+    NodeList<FormalParameter> parameters2 = node.parameters;
+    int size2 = parameters2.length;
     for (int i = 0; i < size2; i++) {
-      FormalParameter parameter = parameters10[i];
+      FormalParameter parameter = parameters2[i];
       if (i > 0) {
         _writer.print(", ");
       }
       if (groupEnd == null && parameter is DefaultFormalParameter) {
         if (identical(parameter.kind, ParameterKind.NAMED)) {
           groupEnd = "}";
           _writer.print('{');
         } else {
           groupEnd = "]";
           _writer.print('[');
         }
       }
       parameter.accept(this);
     }
     if (groupEnd != null) {
       _writer.print(groupEnd);
     }
     _writer.print(')');
     return null;
   }
   Object visitForStatement(ForStatement node) {
-    Expression initialization3 = node.initialization;
+    Expression initialization2 = node.initialization;
     _writer.print("for (");
-    if (initialization3 != null) {
-      visit(initialization3);
+    if (initialization2 != null) {
+      visit(initialization2);
     } else {
       visit(node.variables);
     }
     _writer.print(";");
     visit3(" ", node.condition);
     _writer.print(";");
     visitList4(" ", node.updaters, ", ");
     _writer.print(") ");
     visit(node.body);
     return null;
@@ skipping 242 matching lines @@
     _writer.print("this");
     visit3(".", node.constructorName);
     visit(node.argumentList);
     return null;
   }
   Object visitRethrowExpression(RethrowExpression node) {
     _writer.print("rethrow");
     return null;
   }
   Object visitReturnStatement(ReturnStatement node) {
-    Expression expression14 = node.expression;
-    if (expression14 == null) {
+    Expression expression2 = node.expression;
+    if (expression2 == null) {
       _writer.print("return;");
     } else {
       _writer.print("return ");
-      expression14.accept(this);
+      expression2.accept(this);
       _writer.print(";");
     }
     return null;
   }
   Object visitScriptTag(ScriptTag node) {
     _writer.print(node.scriptTag.lexeme);
     return null;
   }
   Object visitShowCombinator(ShowCombinator node) {
     _writer.print("show ");
@@ skipping 181 matching lines @@
   void visitList(NodeList<ASTNode> nodes) {
     visitList2(nodes, "");
   }
   /**
    * Print a list of nodes, separated by the given separator.
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    */
   void visitList2(NodeList<ASTNode> nodes, String separator) {
     if (nodes != null) {
-      int size3 = nodes.length;
-      for (int i = 0; i < size3; i++) {
+      int size2 = nodes.length;
+      for (int i = 0; i < size2; i++) {
         if (i > 0) {
           _writer.print(separator);
         }
         nodes[i].accept(this);
       }
     }
   }
   /**
    * Print a list of nodes, separated by the given separator.
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    * @param suffix the suffix to be printed if the list is not empty
    */
   void visitList3(NodeList<ASTNode> nodes, String separator, String suffix) {
     if (nodes != null) {
-      int size4 = nodes.length;
-      if (size4 > 0) {
-        for (int i = 0; i < size4; i++) {
+      int size2 = nodes.length;
+      if (size2 > 0) {
+        for (int i = 0; i < size2; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
         _writer.print(suffix);
       }
     }
   }
   /**
    * Print a list of nodes, separated by the given separator.
    * @param prefix the prefix to be printed if the list is not empty
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    */
   void visitList4(String prefix, NodeList<ASTNode> nodes, String separator) {
     if (nodes != null) {
-      int size5 = nodes.length;
-      if (size5 > 0) {
+      int size2 = nodes.length;
+      if (size2 > 0) {
         _writer.print(prefix);
-        for (int i = 0; i < size5; i++) {
+        for (int i = 0; i < size2; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }
 /**
@@ skipping 21 matching lines @@
   Comment visitComment(Comment node) {
     if (node.isDocumentation()) {
       return Comment.createDocumentationComment2(node.tokens, clone2(node.references));
     } else if (node.isBlock()) {
       return Comment.createBlockComment(node.tokens);
     }
     return Comment.createEndOfLineComment(node.tokens);
   }
   CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(node.newKeyword, clone(node.identifier));
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit clone3 = new CompilationUnit.full(node.beginToken, clone(node.scriptTag), clone2(node.directives), clone2(node.declarations), node.endToken);
-    clone3.lineInfo = node.lineInfo;
-    clone3.parsingErrors = node.parsingErrors;
-    clone3.resolutionErrors = node.resolutionErrors;
-    return clone3;
+    CompilationUnit clone22 = new CompilationUnit.full(node.beginToken, clone(node.scriptTag), clone2(node.directives), clone2(node.declarations), node.endToken);
+    clone22.lineInfo = node.lineInfo;
+    clone22.parsingErrors = node.parsingErrors;
+    clone22.resolutionErrors = node.resolutionErrors;
+    return clone22;
   }
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression.full(clone(node.condition), node.question, clone(node.thenExpression), node.colon, clone(node.elseExpression));
   ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, clone(node.returnType), node.period, clone(node.name), clone(node.parameters), node.separator, clone2(node.initializers), clone(node.redirectedConstructor), clone(node.body));
   ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer.full(node.keyword, node.period, clone(node.fieldName), node.equals, clone(node.expression));
   ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName.full(clone(node.type), node.period, clone(node.name));
   ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement.full(node.keyword, clone(node.label), node.semicolon);
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.type), clone(node.identifier));
   DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter.full(clone(node.parameter), node.kind, node.separator, clone(node.defaultValue));
   DoStatement visitDoStatement(DoStatement node) => new DoStatement.full(node.doKeyword, clone(node.body), node.whileKeyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, node.semicolon);
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral.full(node.literal, node.value);
@@ skipping 12 matching lines @@
   FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone(node.functionDeclaration));
   FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression.full(clone(node.parameters), clone(node.body));
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone(node.function), clone(node.argumentList));
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.returnType), clone(node.name), clone(node.typeParameters), clone(node.parameters), node.semicolon);
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone(node.documentationComment), clone2(node.metadata), clone(node.returnType), clone(node.identifier), clone(node.parameters));
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone2(node.hiddenNames));
   IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, clone(node.thenStatement), node.elseKeyword, clone(node.elseStatement));
   ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(node.keyword, clone2(node.interfaces));
   ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.uri), node.asToken, clone(node.prefix), clone2(node.combinators), node.semicolon);
   IndexExpression visitIndexExpression(IndexExpression node) {
-    Token period13 = node.period;
-    if (period13 == null) {
+    Token period2 = node.period;
+    if (period2 == null) {
       return new IndexExpression.forTarget_full(clone(node.array), node.leftBracket, clone(node.index), node.rightBracket);
     } else {
-      return new IndexExpression.forCascade_full(period13, node.leftBracket, clone(node.index), node.rightBracket);
+      return new IndexExpression.forCascade_full(period2, node.leftBracket, clone(node.index), node.rightBracket);
     }
   }
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression.full(node.keyword, clone(node.constructorName), clone(node.argumentList));
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral.full(node.literal, node.value);
   InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(node.leftBracket, clone(node.expression), node.rightBracket);
   InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(node.contents, node.value);
   IsExpression visitIsExpression(IsExpression node) => new IsExpression.full(clone(node.expression), node.isOperator, node.notOperator, clone(node.type));
   Label visitLabel(Label node) => new Label.full(clone(node.label), node.colon);
   LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement.full(clone2(node.labels), clone(node.statement));
   LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective.full(clone(node.documentationComment), clone2(node.metadata), node.libraryToken, clone(node.name), node.semicolon);
@@ skipping 114 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;
   }
 }