Improve java2dart code style - relax 'don't reference variable name in its initializer'.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 63 matching lines @@
    * Return the last token included in this node's source range.
    * @return the last token included in this node's source range
    */
   Token get endToken;
 
   /**
    * Return the number of characters in the node's source range.
    * @return the number of characters in the node's source range
    */
   int get length {
-    Token beginToken2 = beginToken;
-    Token endToken2 = endToken;
-    if (beginToken2 == null || endToken2 == null) {
+    Token beginToken = this.beginToken;
+    Token endToken = this.endToken;
+    if (beginToken == null || endToken == null) {
       return -1;
     }
-    return endToken2.offset + endToken2.length - beginToken2.offset;
+    return endToken.offset + endToken.length - beginToken.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 beginToken2 = beginToken;
-    if (beginToken2 == null) {
+    Token beginToken = this.beginToken;
+    if (beginToken == 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.
@@ skipping 13 matching lines @@
     return _propertyMap[propertyName];
   }
 
   /**
    * Return the node at the root of this node's AST structure. Note that this method's performance
    * is linear with respect to the depth of the node in the AST structure (O(depth)).
    * @return the node at the root of this node's AST structure
    */
   ASTNode get root {
     ASTNode root = this;
-    ASTNode parent2 = parent;
-    while (parent2 != null) {
-      root = parent2;
-      parent2 = root.parent;
+    ASTNode parent = this.parent;
+    while (parent != null) {
+      root = parent;
+      parent = root.parent;
     }
     return root;
   }
 
   /**
    * Return {@code true} if this node is a synthetic node. A synthetic node is a node that was
    * introduced by the parser in order to recover from an error in the code. Synthetic nodes always
    * have a length of zero ({@code 0}).
    * @return {@code true} if this node is a synthetic node
    */
@@ skipping 1305 matching lines @@
    * which the value of the right operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightOperand {
     if (_propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _propagatedElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the right operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForRightOperand {
     if (_staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _staticElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 }
 /**
  * Instances of the class {@code Block} represent a sequence of statements.
  * <pre>
  * block ::=
  * '{' statement* '}'
  * </pre>
  * @coverage dart.engine.ast
  */
@@ skipping 1479 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 endToken2 = endToken;
-    if (endToken2 == null) {
+    Token endToken = this.endToken;
+    if (endToken == null) {
       return 0;
     }
-    return endToken2.offset + endToken2.length;
+    return endToken.offset + endToken.length;
   }
 
   /**
    * Get the {@link LineInfo} object for this compilation unit.
    * @return the associated {@link LineInfo}
    */
   LineInfo get lineInfo => _lineInfo;
   int get offset => 0;
 
   /**
@@ skipping 1075 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 identifier2 = identifier;
-    if (identifier2 == null) {
+    SimpleIdentifier identifier = this.identifier;
+    if (identifier == null) {
       return null;
     }
-    return identifier2.element as LocalVariableElement;
+    return identifier.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;
 
   /**
@@ skipping 631 matching lines @@
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'export' keyword
    * @param libraryUri the URI of the library being exported
    * @param combinators the combinators used to control which names are exported
    * @param semicolon the semicolon terminating the directive
    */
   ExportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
   LibraryElement get uriElement {
-    Element element2 = element;
-    if (element2 is ExportElement) {
-      return ((element2 as ExportElement)).exportedLibrary;
+    Element element = this.element;
+    if (element is ExportElement) {
+      return ((element as ExportElement)).exportedLibrary;
     }
     return null;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code Expression} defines the behavior common to nodes that represent an
@@ skipping 19 matching lines @@
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on propagated type information, 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 parent2 = parent;
-    if (parent2 is ArgumentList) {
-      return ((parent2 as ArgumentList)).getPropagatedParameterElementFor(this);
-    } else if (parent2 is IndexExpression) {
-      IndexExpression indexExpression = parent2 as IndexExpression;
+    ASTNode parent = this.parent;
+    if (parent is ArgumentList) {
+      return ((parent as ArgumentList)).getPropagatedParameterElementFor(this);
+    } else if (parent is IndexExpression) {
+      IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.propagatedParameterElementForIndex;
       }
-    } else if (parent2 is BinaryExpression) {
-      BinaryExpression binaryExpression = parent2 as BinaryExpression;
+    } else if (parent is BinaryExpression) {
+      BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.propagatedParameterElementForRightOperand;
       }
-    } else if (parent2 is PrefixExpression) {
-      return ((parent2 as PrefixExpression)).propagatedParameterElementForOperand;
-    } else if (parent2 is PostfixExpression) {
-      return ((parent2 as PostfixExpression)).propagatedParameterElementForOperand;
+    } else if (parent is PrefixExpression) {
+      return ((parent as PrefixExpression)).propagatedParameterElementForOperand;
+    } else if (parent is PostfixExpression) {
+      return ((parent as PostfixExpression)).propagatedParameterElementForOperand;
     }
     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;
 
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on static type information, 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 staticParameterElement {
-    ASTNode parent2 = parent;
-    if (parent2 is ArgumentList) {
-      return ((parent2 as ArgumentList)).getStaticParameterElementFor(this);
-    } else if (parent2 is IndexExpression) {
-      IndexExpression indexExpression = parent2 as IndexExpression;
+    ASTNode parent = this.parent;
+    if (parent is ArgumentList) {
+      return ((parent as ArgumentList)).getStaticParameterElementFor(this);
+    } else if (parent is IndexExpression) {
+      IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.staticParameterElementForIndex;
       }
-    } else if (parent2 is BinaryExpression) {
-      BinaryExpression binaryExpression = parent2 as BinaryExpression;
+    } else if (parent is BinaryExpression) {
+      BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.staticParameterElementForRightOperand;
       }
-    } else if (parent2 is PrefixExpression) {
-      return ((parent2 as PrefixExpression)).staticParameterElementForOperand;
-    } else if (parent2 is PostfixExpression) {
-      return ((parent2 as PostfixExpression)).staticParameterElementForOperand;
+    } else if (parent is PrefixExpression) {
+      return ((parent as PrefixExpression)).staticParameterElementForOperand;
+    } else if (parent is PostfixExpression) {
+      return ((parent as PostfixExpression)).staticParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * Return the static type of this expression, or {@code null} if the AST structure has not been
    * resolved.
    * @return the static type of this expression
    */
   Type2 get staticType => _staticType;
@@ skipping 954 matching lines @@
  * @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 identifier2 = identifier;
-    if (identifier2 == null) {
+    SimpleIdentifier identifier = this.identifier;
+    if (identifier == null) {
       return null;
     }
-    return identifier2.element as ParameterElement;
+    return identifier.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.
@@ skipping 1236 matching lines @@
    */
   Token get asToken => _asToken;
 
   /**
    * Return the prefix to be used with the imported names, or {@code null} if the imported names are
    * not prefixed.
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
   LibraryElement get uriElement {
-    Element element2 = element;
-    if (element2 is ImportElement) {
-      return ((element2 as ImportElement)).importedLibrary;
+    Element element = this.element;
+    if (element is ImportElement) {
+      return ((element as ImportElement)).importedLibrary;
     }
     return null;
   }
 
   /**
    * Set the token representing the 'as' token to the given token.
    * @param asToken the token representing the 'as' token
    */
   void set asToken(Token asToken2) {
     this._asToken = asToken2;
@@ skipping 192 matching lines @@
   MethodElement get staticElement => _staticElement;
 
   /**
    * 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 parent2 = parent;
-    if (parent2 is AssignmentExpression) {
-      AssignmentExpression assignment = parent2 as AssignmentExpression;
+    ASTNode parent = this.parent;
+    if (parent is AssignmentExpression) {
+      AssignmentExpression assignment = parent 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 parent2 = parent;
-    if (parent2 is PrefixExpression) {
-      return ((parent2 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent2 is PostfixExpression) {
+    ASTNode parent = this.parent;
+    if (parent is PrefixExpression) {
+      return ((parent as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent is PostfixExpression) {
       return true;
-    } else if (parent2 is AssignmentExpression) {
-      return identical(((parent2 as AssignmentExpression)).leftHandSide, this);
+    } else if (parent is AssignmentExpression) {
+      return identical(((parent 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
    */
@@ skipping 67 matching lines @@
    * which the value of the index expression will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the index
    * expression will be bound
    */
   ParameterElement get propagatedParameterElementForIndex {
     if (_propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _propagatedElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the index expression will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the index
    * expression will be bound
    */
   ParameterElement get staticParameterElementForIndex {
     if (_staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _staticElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 }
 /**
  * Instances of the class {@code InstanceCreationExpression} represent an instance creation
  * expression.
  * <pre>
  * newExpression ::=
  * ('new' | 'const') {@link TypeName type} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList argumentList}</pre>
  * @coverage dart.engine.ast
  */
@@ skipping 846 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 typeArguments2 = typeArguments;
-    if (typeArguments2 != null) {
-      return typeArguments2.beginToken;
+    TypeArgumentList typeArguments = this.typeArguments;
+    if (typeArguments != null) {
+      return typeArguments.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 89 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 typeArguments2 = typeArguments;
-    if (typeArguments2 != null) {
-      return typeArguments2.beginToken;
+    TypeArgumentList typeArguments = this.typeArguments;
+    if (typeArguments != null) {
+      return typeArguments.beginToken;
     }
     return _leftBracket;
   }
   Token get endToken => _rightBracket;
 
   /**
    * Return the entries in the map.
    * @return the entries in the map
    */
   NodeList<MapLiteralEntry> get entries => _entries;
@@ skipping 593 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 element2 = _name.label.element;
-    if (element2 is ParameterElement) {
-      return element2 as ParameterElement;
+    Element element = _name.label.element;
+    if (element is ParameterElement) {
+      return element 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;
@@ skipping 226 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 parent2 = parent;
-    if (parent2 is DefaultFormalParameter) {
-      return ((parent2 as DefaultFormalParameter)).kind;
+    ASTNode parent = this.parent;
+    if (parent is DefaultFormalParameter) {
+      return ((parent 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;
 
@@ skipping 521 matching lines @@
    * which the value of the operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _propagatedElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _staticElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 }
 /**
  * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
  * <pre>
  * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
  * @coverage dart.engine.ast
  */
 class PrefixExpression extends Expression {
 
@@ skipping 110 matching lines @@
    * which the value of the operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _propagatedElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = _staticElement.parameters;
-    if (parameters2.length < 1) {
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
       return null;
     }
-    return parameters2[0];
+    return parameters[0];
   }
 }
 /**
  * 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>
  * prefixedIdentifier ::={@link SimpleIdentifier prefix} '.' {@link SimpleIdentifier identifier}</pre>
  * @coverage dart.engine.ast
  */
@@ skipping 772 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 parent2 = parent;
-    if (parent2 is CatchClause) {
-      CatchClause clause = parent2 as CatchClause;
+    ASTNode parent = this.parent;
+    if (parent is CatchClause) {
+      CatchClause clause = parent as CatchClause;
       return identical(this, clause.exceptionParameter) || identical(this, clause.stackTraceParameter);
-    } 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);
+    } else if (parent is ClassDeclaration) {
+      return identical(this, ((parent as ClassDeclaration)).name);
+    } else if (parent is ClassTypeAlias) {
+      return identical(this, ((parent as ClassTypeAlias)).name);
+    } else if (parent is ConstructorDeclaration) {
+      return identical(this, ((parent as ConstructorDeclaration)).name);
+    } else if (parent is FunctionDeclaration) {
+      return identical(this, ((parent as FunctionDeclaration)).name);
+    } else if (parent is FunctionTypeAlias) {
+      return identical(this, ((parent as FunctionTypeAlias)).name);
+    } else if (parent is Label) {
+      return identical(this, ((parent as Label)).label) && (parent.parent is LabeledStatement);
+    } else if (parent is MethodDeclaration) {
+      return identical(this, ((parent as MethodDeclaration)).name);
+    } else if (parent is FunctionTypedFormalParameter || parent is SimpleFormalParameter) {
+      return identical(this, ((parent as NormalFormalParameter)).identifier);
+    } else if (parent is TypeParameter) {
+      return identical(this, ((parent as TypeParameter)).name);
+    } else if (parent is VariableDeclaration) {
+      return identical(this, ((parent 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 parent2 = parent;
+    ASTNode parent = this.parent;
     ASTNode target = this;
-    if (parent2 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent2 as PrefixedIdentifier;
+    if (parent is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
-      parent2 = prefixed.parent;
+      parent = prefixed.parent;
       target = prefixed;
-    } else if (parent2 is PropertyAccess) {
-      PropertyAccess access = parent2 as PropertyAccess;
+    } else if (parent is PropertyAccess) {
+      PropertyAccess access = parent as PropertyAccess;
       if (identical(access.target, this)) {
         return true;
       }
-      parent2 = access.parent;
+      parent = access.parent;
       target = access;
     }
-    if (parent2 is Label) {
+    if (parent is Label) {
       return false;
     }
-    if (parent2 is AssignmentExpression) {
-      AssignmentExpression expr = parent2 as AssignmentExpression;
+    if (parent is AssignmentExpression) {
+      AssignmentExpression expr = parent 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 parent2 = parent;
+    ASTNode parent = this.parent;
     ASTNode target = this;
-    if (parent2 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent2 as PrefixedIdentifier;
+    if (parent is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return false;
       }
-      parent2 = prefixed.parent;
+      parent = prefixed.parent;
       target = prefixed;
-    } else if (parent2 is PropertyAccess) {
-      PropertyAccess access = parent2 as PropertyAccess;
+    } else if (parent is PropertyAccess) {
+      PropertyAccess access = parent as PropertyAccess;
       if (identical(access.target, this)) {
         return false;
       }
-      parent2 = access.parent;
+      parent = access.parent;
       target = access;
     }
-    if (parent2 is PrefixExpression) {
-      return ((parent2 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent2 is PostfixExpression) {
+    if (parent is PrefixExpression) {
+      return ((parent as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent is PostfixExpression) {
       return true;
-    } else if (parent2 is AssignmentExpression) {
-      return identical(((parent2 as AssignmentExpression)).leftHandSide, target);
+    } else if (parent is AssignmentExpression) {
+      return identical(((parent as AssignmentExpression)).leftHandSide, target);
     }
     return false;
   }
   bool isSynthetic() => _token.isSynthetic();
 
   /**
    * Set the element associated with this identifier based on propagated type information to the
    * given element.
    * @param element the element to be associated with this identifier
    */
@@ skipping 1803 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 parent2 = parent;
-    return parent2 is VariableDeclarationList && ((parent2 as VariableDeclarationList)).isConst();
+    ASTNode parent = this.parent;
+    return parent is VariableDeclarationList && ((parent 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 parent2 = parent;
-    return parent2 is VariableDeclarationList && ((parent2 as VariableDeclarationList)).isFinal();
+    ASTNode parent = this.parent;
+    return parent is VariableDeclarationList && ((parent 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 equals2) {
     this._equals = equals2;
   }
 
@@ skipping 492 matching lines @@
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.append(value);
     }
     return builder.toString();
   }
   Object visitBinaryExpression(BinaryExpression node) {
-    Object leftOperand2 = node.leftOperand.accept(this);
-    if (identical(leftOperand2, NOT_A_CONSTANT)) {
-      return leftOperand2;
+    Object leftOperand = node.leftOperand.accept(this);
+    if (identical(leftOperand, NOT_A_CONSTANT)) {
+      return leftOperand;
     }
-    Object rightOperand2 = node.rightOperand.accept(this);
-    if (identical(rightOperand2, NOT_A_CONSTANT)) {
-      return rightOperand2;
+    Object rightOperand = node.rightOperand.accept(this);
+    if (identical(rightOperand, NOT_A_CONSTANT)) {
+      return rightOperand;
     }
     while (true) {
       if (node.operator.type == TokenType.AMPERSAND) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) & (rightOperand2 as int);
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) & (rightOperand as int);
         }
       } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
-        if (leftOperand2 is bool && rightOperand2 is bool) {
-          return ((leftOperand2 as bool)) && ((rightOperand2 as bool));
+        if (leftOperand is bool && rightOperand is bool) {
+          return ((leftOperand as bool)) && ((rightOperand as bool));
         }
       } else if (node.operator.type == TokenType.BANG_EQ) {
-        if (leftOperand2 is bool && rightOperand2 is bool) {
-          return ((leftOperand2 as bool)) != ((rightOperand2 as bool));
-        } else if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) != rightOperand2;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) != rightOperand2;
-        } else if (leftOperand2 is String && rightOperand2 is String) {
-          return ((leftOperand2 as String)) != rightOperand2;
+        if (leftOperand is bool && rightOperand is bool) {
+          return ((leftOperand as bool)) != ((rightOperand as bool));
+        } else if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) != rightOperand;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) != rightOperand;
+        } else if (leftOperand is String && rightOperand is String) {
+          return ((leftOperand as String)) != rightOperand;
         }
       } else if (node.operator.type == TokenType.BAR) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) | (rightOperand2 as int);
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) | (rightOperand as int);
         }
       } else if (node.operator.type == TokenType.BAR_BAR) {
-        if (leftOperand2 is bool && rightOperand2 is bool) {
-          return ((leftOperand2 as bool)) || ((rightOperand2 as bool));
+        if (leftOperand is bool && rightOperand is bool) {
+          return ((leftOperand as bool)) || ((rightOperand as bool));
         }
       } else if (node.operator.type == TokenType.CARET) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) ^ (rightOperand2 as int);
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) ^ (rightOperand as int);
         }
       } else if (node.operator.type == TokenType.EQ_EQ) {
-        if (leftOperand2 is bool && rightOperand2 is bool) {
-          return identical(((leftOperand2 as bool)), ((rightOperand2 as bool)));
-        } else if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) == rightOperand2;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) == rightOperand2;
-        } else if (leftOperand2 is String && rightOperand2 is String) {
-          return ((leftOperand2 as String)) == rightOperand2;
+        if (leftOperand is bool && rightOperand is bool) {
+          return identical(((leftOperand as bool)), ((rightOperand as bool)));
+        } else if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) == rightOperand;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) == rightOperand;
+        } else if (leftOperand is String && rightOperand is String) {
+          return ((leftOperand as String)) == rightOperand;
         }
       } else if (node.operator.type == TokenType.GT) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) > 0;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) > 0;
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)).compareTo((rightOperand as int)) > 0;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)).compareTo((rightOperand as double)) > 0;
         }
       } else if (node.operator.type == TokenType.GT_EQ) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) >= 0;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) >= 0;
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)).compareTo((rightOperand as int)) >= 0;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)).compareTo((rightOperand as double)) >= 0;
         }
       } else if (node.operator.type == TokenType.GT_GT) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) >> ((rightOperand2 as int));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) >> ((rightOperand as int));
         }
       } else if (node.operator.type == TokenType.LT) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) < 0;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) < 0;
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)).compareTo((rightOperand as int)) < 0;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)).compareTo((rightOperand as double)) < 0;
         }
       } else if (node.operator.type == TokenType.LT_EQ) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) <= 0;
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) <= 0;
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)).compareTo((rightOperand as int)) <= 0;
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)).compareTo((rightOperand as double)) <= 0;
         }
       } else if (node.operator.type == TokenType.LT_LT) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) << ((rightOperand2 as int));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) << ((rightOperand as int));
         }
       } else if (node.operator.type == TokenType.MINUS) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) - (rightOperand2 as int);
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) - ((rightOperand2 as double));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) - (rightOperand as int);
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) - ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.PERCENT) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)).remainder((rightOperand2 as int));
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) % ((rightOperand2 as double));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)).remainder((rightOperand as int));
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) % ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.PLUS) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) + (rightOperand2 as int);
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) + ((rightOperand2 as double));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) + (rightOperand as int);
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) + ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.STAR) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) * (rightOperand2 as int);
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) * ((rightOperand2 as double));
+        if (leftOperand is int && rightOperand is int) {
+          return ((leftOperand as int)) * (rightOperand as int);
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) * ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.SLASH) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          if (rightOperand2 != 0) {
-            return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+        if (leftOperand is int && rightOperand is int) {
+          if (rightOperand != 0) {
+            return ((leftOperand as int)) ~/ (rightOperand as int);
           } else {
-            return ((leftOperand2 as int)).toDouble() / ((rightOperand2 as int)).toDouble();
+            return ((leftOperand as int)).toDouble() / ((rightOperand as int)).toDouble();
           }
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) / ((rightOperand2 as double));
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) / ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
-        if (leftOperand2 is int && rightOperand2 is int) {
-          if (rightOperand2 != 0) {
-            return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+        if (leftOperand is int && rightOperand is int) {
+          if (rightOperand != 0) {
+            return ((leftOperand as int)) ~/ (rightOperand as int);
           } else {
             return 0;
           }
-        } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
+        } else if (leftOperand is double && rightOperand is double) {
+          return ((leftOperand as double)) ~/ ((rightOperand as double));
         }
       }
       break;
     }
     return visitExpression(node);
   }
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
   Object visitIntegerLiteral(IntegerLiteral node) => node.value;
   Object visitInterpolationExpression(InterpolationExpression node) {
@@ skipping 11 matching lines @@
       if (identical(value, NOT_A_CONSTANT)) {
         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 value2 = entry.value.accept(this);
-      if (key2 is! String || identical(value2, NOT_A_CONSTANT)) {
+      Object key = entry.key.accept(this);
+      Object value = entry.value.accept(this);
+      if (key is! String || identical(value, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
-      map[(key2 as String)] = value2;
+      map[(key as String)] = value;
     }
     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);
-    if (identical(operand2, NOT_A_CONSTANT)) {
-      return operand2;
+    Object operand = node.operand.accept(this);
+    if (identical(operand, NOT_A_CONSTANT)) {
+      return operand;
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
-        if (identical(operand2, true)) {
+        if (identical(operand, true)) {
           return false;
-        } else if (identical(operand2, false)) {
+        } else if (identical(operand, false)) {
           return true;
         }
       } else if (node.operator.type == TokenType.TILDE) {
-        if (operand2 is int) {
-          return ~((operand2 as int));
+        if (operand is int) {
+          return ~((operand as int));
         }
       } else if (node.operator.type == TokenType.MINUS) {
-        if (operand2 == null) {
+        if (operand == null) {
           return null;
-        } else if (operand2 is int) {
-          return -((operand2 as int));
-        } else if (operand2 is double) {
-          return -((operand2 as double));
+        } else if (operand is int) {
+          return -((operand as int));
+        } else if (operand is double) {
+          return -((operand as double));
         }
       }
       break;
     }
     return NOT_A_CONSTANT;
   }
   Object visitPropertyAccess(PropertyAccess node) => getConstantValue(null);
   Object visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(null);
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
   Object visitStringInterpolation(StringInterpolation node) {
@@ skipping 42 matching lines @@
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
   Element visitBinaryExpression(BinaryExpression node) => node.element;
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
   Element visitCompilationUnit(CompilationUnit node) => node.element;
   Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
   Element visitIdentifier(Identifier node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is ConstructorDeclaration) {
-      ConstructorDeclaration decl = parent2 as ConstructorDeclaration;
-      Identifier returnType2 = decl.returnType;
-      if (identical(returnType2, node)) {
-        SimpleIdentifier name2 = decl.name;
-        if (name2 != null) {
-          return name2.element;
+    ASTNode parent = node.parent;
+    if (parent is ConstructorDeclaration) {
+      ConstructorDeclaration decl = parent as ConstructorDeclaration;
+      Identifier returnType = decl.returnType;
+      if (identical(returnType, node)) {
+        SimpleIdentifier name = decl.name;
+        if (name != null) {
+          return name.element;
         }
-        Element element2 = node.element;
-        if (element2 is ClassElement) {
-          return ((element2 as ClassElement)).unnamedConstructor;
+        Element element = node.element;
+        if (element is ClassElement) {
+          return ((element as ClassElement)).unnamedConstructor;
         }
       }
     }
-    if (parent2 is LibraryIdentifier) {
-      ASTNode grandParent = ((parent2 as LibraryIdentifier)).parent;
+    if (parent is LibraryIdentifier) {
+      ASTNode grandParent = ((parent as LibraryIdentifier)).parent;
       if (grandParent is PartOfDirective) {
-        Element element3 = ((grandParent as PartOfDirective)).element;
-        if (element3 is LibraryElement) {
-          return ((element3 as LibraryElement)).definingCompilationUnit;
+        Element element = ((grandParent as PartOfDirective)).element;
+        if (element is LibraryElement) {
+          return ((element as LibraryElement)).definingCompilationUnit;
         }
       }
     }
     return node.element;
   }
   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 parent2 = node.parent;
-    if (parent2 is UriBasedDirective) {
-      return ((parent2 as UriBasedDirective)).uriElement;
+    ASTNode parent = node.parent;
+    if (parent is UriBasedDirective) {
+      return ((parent as UriBasedDirective)).uriElement;
     }
     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 902 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 scriptTag2 = node.scriptTag;
-    NodeList<Directive> directives2 = node.directives;
-    visit(scriptTag2);
-    String prefix = scriptTag2 == null ? "" : " ";
-    visitList4(prefix, directives2, " ");
-    prefix = scriptTag2 == null && directives2.isEmpty ? "" : " ";
+    ScriptTag scriptTag = node.scriptTag;
+    NodeList<Directive> directives = node.directives;
+    visit(scriptTag);
+    String prefix = scriptTag == null ? "" : " ";
+    visitList4(prefix, directives, " ");
+    prefix = scriptTag == null && directives.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> parameters2 = node.parameters;
-    int size2 = parameters2.length;
-    for (int i = 0; i < size2; i++) {
-      FormalParameter parameter = parameters2[i];
+    NodeList<FormalParameter> parameters = node.parameters;
+    int size = parameters.length;
+    for (int i = 0; i < size; i++) {
+      FormalParameter parameter = parameters[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 initialization2 = node.initialization;
+    Expression initialization = node.initialization;
     _writer.print("for (");
-    if (initialization2 != null) {
-      visit(initialization2);
+    if (initialization != null) {
+      visit(initialization);
     } 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 expression2 = node.expression;
-    if (expression2 == null) {
+    Expression expression = node.expression;
+    if (expression == null) {
       _writer.print("return;");
     } else {
       _writer.print("return ");
-      expression2.accept(this);
+      expression.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 188 matching lines @@
     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 size2 = nodes.length;
-      for (int i = 0; i < size2; i++) {
+      int size = nodes.length;
+      for (int i = 0; i < size; 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 size2 = nodes.length;
-      if (size2 > 0) {
-        for (int i = 0; i < size2; i++) {
+      int size = nodes.length;
+      if (size > 0) {
+        for (int i = 0; i < size; 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 size2 = nodes.length;
-      if (size2 > 0) {
+      int size = nodes.length;
+      if (size > 0) {
         _writer.print(prefix);
-        for (int i = 0; i < size2; i++) {
+        for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }
 /**
@@ skipping 58 matching lines @@
   FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone2(node.functionDeclaration));
   FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression.full(clone2(node.parameters), clone2(node.body));
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone2(node.function), clone2(node.argumentList));
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.returnType), clone2(node.name), clone2(node.typeParameters), clone2(node.parameters), node.semicolon);
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.returnType), clone2(node.identifier), clone2(node.parameters));
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone3(node.hiddenNames));
   IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.thenStatement), node.elseKeyword, clone2(node.elseStatement));
   ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(node.keyword, clone3(node.interfaces));
   ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), node.asToken, clone2(node.prefix), clone3(node.combinators), node.semicolon);
   IndexExpression visitIndexExpression(IndexExpression node) {
-    Token period2 = node.period;
-    if (period2 == null) {
+    Token period = node.period;
+    if (period == null) {
       return new IndexExpression.forTarget_full(clone2(node.array), node.leftBracket, clone2(node.index), node.rightBracket);
     } else {
-      return new IndexExpression.forCascade_full(period2, node.leftBracket, clone2(node.index), node.rightBracket);
+      return new IndexExpression.forCascade_full(period, node.leftBracket, clone2(node.index), node.rightBracket);
     }
   }
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression.full(node.keyword, clone2(node.constructorName), clone2(node.argumentList));
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral.full(node.literal, node.value);
   InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(node.leftBracket, clone2(node.expression), node.rightBracket);
   InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(node.contents, node.value);
   IsExpression visitIsExpression(IsExpression node) => new IsExpression.full(clone2(node.expression), node.isOperator, node.notOperator, clone2(node.type));
   Label visitLabel(Label node) => new Label.full(clone2(node.label), node.colon);
   LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement.full(clone3(node.labels), clone2(node.statement));
   LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.libraryToken, clone2(node.name), node.semicolon);
@@ skipping 126 matching lines @@
       return null;
     }
     if (_immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
     _declarationNode = node;
     return null;
   }
   Object visitNode(ASTNode node) {
     _immediateChild = node;
-    ASTNode parent2 = node.parent;
-    if (parent2 != null) {
-      parent2.accept(this);
+    ASTNode parent = node.parent;
+    if (parent != null) {
+      parent.accept(this);
     }
     return null;
   }
   Object visitSwitchMember(SwitchMember node) {
     checkStatements(node.statements);
     return super.visitSwitchMember(node);
   }
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _declarationNode = node;
     return null;
   }
   Object visitTypeAlias(TypeAlias node) {
     _declarationNode = node;
     return null;
   }
   void addParameters(NodeList<FormalParameter> vars) {
     for (FormalParameter var2 in vars) {
       addToScope(var2.identifier);
     }
   }
   void addToScope(SimpleIdentifier identifier) {
     if (identifier != null && isInRange(identifier)) {
-      String name2 = identifier.name;
-      if (!_locals.containsKey(name2)) {
-        _locals[name2] = identifier;
+      String name = identifier.name;
+      if (!_locals.containsKey(name)) {
+        _locals[name] = identifier;
       }
     }
   }
   void addVariables(NodeList<VariableDeclaration> vars) {
     for (VariableDeclaration var2 in vars) {
       addToScope(var2.name);
     }
   }
 
   /**
@@ skipping 79 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;
   }
 }