Update analyzer-experimental.

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;
 import 'utilities_dart.dart';
 import 'element.dart' hide Annotation;
 
 /**
  * The abstract class {@code ASTNode} defines the behavior common to all nodes in the AST structure
  * for a Dart program.
  */
 abstract class ASTNode {
   /**
    * The parent of the node, or {@code null} if the node is the root of an AST structure.
    */
   ASTNode _parent;
   /**
+   * A table mapping the names of properties to their values, or {@code null} if this node does not
+   * have any properties associated with it.
+   */
+  Map<String, Object> _propertyMap;
+  /**
    * A comparator that can be used to sort AST nodes in lexical order. In other words,{@code compare} will return a negative value if the offset of the first node is less than the
    * offset of the second node, zero (0) if the nodes have the same offset, and a positive value if
    * if the offset of the first node is greater than the offset of the second node.
    */
   static Comparator<ASTNode> LEXICAL_ORDER = (ASTNode first, ASTNode second) => second.offset - first.offset;
   /**
    * Use the given visitor to visit this node.
    * @param visitor the visitor that will visit this node
    * @return the value returned by the visitor as a result of visiting this node
    */
   accept(ASTVisitor visitor);
   /**
    * @return the {@link ASTNode} of given {@link Class} which is {@link ASTNode} itself, or one of
    * its parents.
    */
   ASTNode getAncestor(Type enclosingClass) {
     ASTNode node = this;
     while (node != null && !isInstanceOf(node, enclosingClass)) {
       node = node.parent;
     }
     ;
-    return (node as ASTNode);
+    return node as ASTNode;
   }
   /**
    * Return the first token included in this node's source range.
    * @return the first token included in this node's source range
    */
   Token get beginToken;
   /**
    * Return the offset of the character immediately following the last character of this node's
    * source range. This is equivalent to {@code node.getOffset() + node.getLength()}. For a
    * compilation unit this will be equal to the length of the unit's source. For synthetic nodes
@@ skipping 33 matching lines @@
   }
   /**
    * 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
    */
   ASTNode get parent => _parent;
   /**
+   * Return the value of the property with the given name, or {@code null} if this node does not
+   * have a property with the given name.
+   * @return the value of the property with the given name
+   */
+  Object getProperty(String propertyName) {
+    if (_propertyMap == null) {
+      return null;
+    }
+    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;
     }
     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
    */
   bool isSynthetic() => false;
   /**
+   * Set the value of the property with the given name to the given value. If the value is{@code null}, the property will effectively be removed.
+   * @param propertyName the name of the property whose value is to be set
+   * @param propertyValue the new value of the property
+   */
+  void setProperty(String propertyName, Object propertyValue) {
+    if (propertyValue == null) {
+      if (_propertyMap != null) {
+        _propertyMap.remove(propertyName);
+        if (_propertyMap.isEmpty) {
+          _propertyMap = null;
+        }
+      }
+    } else {
+      if (_propertyMap == null) {
+        _propertyMap = new Map<String, Object>();
+      }
+      _propertyMap[propertyName] = propertyValue;
+    }
+  }
+  /**
    * Return a textual description of this node in a form approximating valid source. The returned
    * string will not be valid source primarily in the case where the node itself is not well-formed.
    * @return the source code equivalent of this node
    */
   String toSource() {
     PrintStringWriter writer = new PrintStringWriter();
     accept(new ToSourceVisitor(writer));
     return writer.toString();
   }
   String toString() => toSource();
@@ skipping 473 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 identifier5) {
-    this._identifier = becomeParentOf(identifier5);
+  void set identifier(SimpleIdentifier identifier7) {
+    this._identifier = becomeParentOf(identifier7);
   }
   /**
    * 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 16 matching lines @@
   Token _leftParenthesis;
   /**
    * The expressions producing the values of the arguments.
    */
   NodeList<Expression> _arguments;
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
   /**
+   * An array containing the elements representing the parameters corresponding to each of the
+   * arguments in this list, or {@code null} if the AST has not been resolved or if the function or
+   * method being invoked could not be determined. The array must be the same length as the number
+   * of arguments, but can contain {@code null} entries if a given argument does not correspond to a
+   * formal parameter.
+   */
+  List<ParameterElement> _correspondingParameters;
+  /**
    * Initialize a newly created list of arguments.
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
   ArgumentList.full(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
     this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
     this._arguments.addAll(arguments);
     this._rightParenthesis = rightParenthesis;
@@ skipping 19 matching lines @@
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
+   * Set the parameter elements corresponding to each of the arguments in this list to the given
+   * array of parameters. The array of parameters must be the same length as the number of
+   * arguments, but can contain {@code null} entries if a given argument does not correspond to a
+   * formal parameter.
+   * @param parameters the parameter elements corresponding to the arguments
+   */
+  void set correspondingParameters(List<ParameterElement> parameters) {
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
+    }
+    _correspondingParameters = parameters;
+  }
+  /**
    * 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.
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
+  /**
+   * If the given expression is a child of this list, and the AST structure has been resolved, and
+   * the function being invoked is known, and the 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 the given expression will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * @param expression the expression corresponding to the parameter to be returned
+   * @return the parameter element representing the parameter to which the value of the expression
+   * will be bound
+   */
+  ParameterElement getParameterElementFor(Expression expression) {
+    if (_correspondingParameters == null) {
+      return null;
+    }
+    int index = _arguments.indexOf(expression);
+    if (index < 0) {
+      return null;
+    }
+    return _correspondingParameters[index];
+  }
 }
 /**
  * Instances of the class {@code AsExpression} represent an 'as' expression.
  * <pre>
  * asExpression ::={@link Expression expression} 'as' {@link TypeName type}</pre>
  */
 class AsExpression extends Expression {
   /**
    * The expression used to compute the value being cast.
    */
@@ skipping 1019 matching lines @@
   /**
    * Return the 'abstract' keyword, or {@code null} if the keyword was absent.
    * @return the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
   /**
    * Return the token representing the 'class' keyword.
    * @return the token representing the 'class' keyword
    */
   Token get classKeyword => _classKeyword;
-  /**
-   * @return the {@link ClassElement} associated with this identifier, or {@code null} if the AST
-   * structure has not been resolved or if this identifier could not be resolved.
-   */
   ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
   Token get endToken => _rightBracket;
   /**
    * Return the extends clause for this class, or {@code null} if the class does not extend any
    * other class.
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
   /**
    * Return the implements clause for the class, or {@code null} if the class does not implement any
@@ skipping 206 matching lines @@
    * @param semicolon the semicolon terminating the declaration
    */
   ClassTypeAlias({Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon}) : this.full(comment, metadata, keyword, name, typeParameters, equals, abstractKeyword, superclass, withClause, implementsClause, semicolon);
   accept(ASTVisitor visitor) => visitor.visitClassTypeAlias(this);
   /**
    * Return the token for the 'abstract' keyword, or {@code null} if this is not defining an
    * abstract class.
    * @return the token for the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
-  /**
-   * Return the {@link ClassElement} associated with this type alias, or {@code null} if the AST
-   * structure has not been resolved.
-   * @return the {@link ClassElement} associated with this type alias
-   */
   ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
   /**
    * Return the token for the '=' separating the name from the definition.
    * @return the token for the '=' separating the name from the definition
    */
   Token get equals => _equals;
   /**
    * Return the implements clause for this class, or {@code null} if there is no implements clause.
    * @return the implements clause for this class
    */
@@ skipping 285 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 identifier18) {
-    identifier18 = becomeParentOf(identifier18);
+  void set identifier(Identifier identifier23) {
+    identifier23 = becomeParentOf(identifier23);
   }
   /**
    * 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 104 matching lines @@
    */
   List<AnalysisError> get errors {
     List<AnalysisError> parserErrors = parsingErrors;
     List<AnalysisError> resolverErrors = resolutionErrors;
     if (resolverErrors.length == 0) {
       return parserErrors;
     } else if (parserErrors.length == 0) {
       return resolverErrors;
     } else {
       List<AnalysisError> allErrors = new List<AnalysisError>(parserErrors.length + resolverErrors.length);
-      System.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
-      System.arraycopy(resolverErrors, 0, allErrors, 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) {
       return 0;
     }
     return endToken3.offset + endToken3.length - beginToken.offset;
   }
@@ skipping 260 matching lines @@
  * initializerList ::=
  * ':' {@link ConstructorInitializer initializer} (',' {@link ConstructorInitializer initializer})
  * </pre>
  */
 class ConstructorDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or {@code null} if the constructor is not external.
    */
   Token _externalKeyword;
   /**
-   * The token for the 'const' keyword.
+   * The token for the 'const' keyword, or {@code null} if the constructor is not a const
+   * constructor.
    */
   Token _constKeyword;
   /**
-   * The token for the 'factory' keyword.
+   * The token for the 'factory' keyword, or {@code null} if the constructor is not a factory
+   * constructor.
    */
   Token _factoryKeyword;
   /**
    * The type of object being created. This can be different than the type in which the constructor
    * is being declared if the constructor is the implementation of a factory constructor.
    */
   Identifier _returnType;
   /**
    * The token for the period before the constructor name, or {@code null} if the constructor being
    * declared is unnamed.
@@ skipping 83 matching lines @@
   /**
    * Return the body of the constructor, or {@code null} if the constructor does not have a body.
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
   /**
    * Return the token for the 'const' keyword.
    * @return the token for the 'const' keyword
    */
   Token get constKeyword => _constKeyword;
-  /**
-   * Return the element associated with this constructor , or {@code null} if the AST structure has
-   * not been resolved or if this constructor could not be resolved.
-   * @return the element associated with this constructor
-   */
   ConstructorElement get element => _element;
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (!_initializers.isEmpty) {
       return _initializers.endToken;
     }
     return _parameters.endToken;
   }
   /**
@@ skipping 124 matching lines @@
    */
   void set separator(Token separator2) {
     this._separator = separator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     _initializers.accept(visitor);
+    safelyVisitChild(_redirectedConstructor, visitor);
     safelyVisitChild(_body, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     Token leftMost2 = leftMost([_externalKeyword, _constKeyword, _factoryKeyword]);
     if (leftMost2 != null) {
       return leftMost2;
     }
     return _returnType.beginToken;
   }
   /**
@@ skipping 352 matching lines @@
    * @param metadata the annotations associated with this declaration
    */
   Declaration.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
   /**
    * Initialize a newly created declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
   Declaration({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
+  /**
+   * Return the element associated with this declaration, or {@code null} if either this node
+   * corresponds to a list of declarations or if the AST structure has not been resolved.
+   * @return the element associated with this declaration
+   */
+  Element get element;
 }
 /**
  * Instances of the class {@code DefaultFormalParameter} represent a formal parameter with a default
  * value. There are two kinds of parameters that are both represented by this class: named formal
  * parameters and positional formal parameters.
  * <pre>
  * defaultFormalParameter ::={@link NormalFormalParameter normalFormalParameter} ('=' {@link Expression defaultValue})?
  * defaultNamedParameter ::={@link NormalFormalParameter normalFormalParameter} (':' {@link Expression defaultValue})?
  * </pre>
  */
@@ skipping 455 matching lines @@
    * 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 visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
+ * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
+ */
+class EphemeralIdentifier extends SimpleIdentifier {
+  EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
+    parent.becomeParentOf(this);
+  }
+  EphemeralIdentifier({ASTNode parent, int location}) : this.full(parent, location);
+}
+/**
  * Instances of the class {@code ExportDirective} represent an export directive.
  * <pre>
  * exportDirective ::={@link Annotation metadata} 'export' {@link StringLiteral libraryUri} {@link Combinator combinator}* ';'
  * </pre>
  */
 class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
@@ skipping 31 matching lines @@
   /**
    * The static type of this expression, or {@code null} if the AST structure has not been resolved.
    */
   Type2 _staticType;
   /**
    * The propagated type of this expression, or {@code null} if type propagation has not been
    * performed on the AST structure.
    */
   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);
+    }
+    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;
   /**
    * 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
    */
@@ skipping 275 matching lines @@
   /**
    * Initialize a newly created field declaration.
    * @param comment the documentation comment associated with this field
    * @param metadata the annotations associated with this field
    * @param keyword the token representing the 'static' keyword
    * @param fieldList the fields being declared
    * @param semicolon the semicolon terminating the declaration
    */
   FieldDeclaration({Comment comment, List<Annotation> metadata, Token keyword, VariableDeclarationList fieldList, Token semicolon}) : this.full(comment, metadata, keyword, fieldList, semicolon);
   accept(ASTVisitor visitor) => visitor.visitFieldDeclaration(this);
+  Element get element => null;
   Token get endToken => _semicolon;
   /**
    * Return the fields being declared.
    * @return the fields being declared
    */
   VariableDeclarationList get fields => _fieldList;
   /**
    * Return the token representing the 'static' keyword, or {@code null} if the fields are not
    * static.
    * @return the token representing the 'static' keyword
@@ skipping 535 matching lines @@
  * <pre>
  * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
  */
 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 identifier9 = identifier;
-    if (identifier9 == null) {
+    SimpleIdentifier identifier11 = identifier;
+    if (identifier11 == null) {
       return null;
     }
-    return (identifier9.element as ParameterElement);
+    return identifier11.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 208 matching lines @@
    * @param comment the documentation comment associated with this function
    * @param metadata the annotations associated with this function
    * @param externalKeyword the token representing the 'external' keyword
    * @param returnType the return type of the function
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
   FunctionDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression}) : this.full(comment, metadata, externalKeyword, returnType, propertyKeyword, name, functionExpression);
   accept(ASTVisitor visitor) => visitor.visitFunctionDeclaration(this);
-  /**
-   * Return the {@link FunctionElement} associated with this function, or {@code null} if the AST
-   * structure has not been resolved.
-   * @return the {@link FunctionElement} associated with this function
-   */
-  FunctionElement get element => _name != null ? (_name.element as FunctionElement) : null;
+  ExecutableElement get element => _name != null ? (_name.element as ExecutableElement) : null;
   Token get endToken => _functionExpression.endToken;
   /**
    * Return the token representing the 'external' keyword, or {@code null} if this is not an
    * external function.
    * @return the token representing the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
   /**
    * Return the function expression being wrapped.
    * @return the function expression being wrapped
@@ skipping 334 matching lines @@
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param returnType the name of the return type of the function type being defined
    * @param name the name of the type being declared
    * @param typeParameters the type parameters for the type
    * @param parameters the parameters associated with the function
    * @param semicolon the semicolon terminating the declaration
    */
   FunctionTypeAlias({Comment comment, List<Annotation> metadata, Token keyword, TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters, FormalParameterList parameters, Token semicolon}) : this.full(comment, metadata, keyword, returnType, name, typeParameters, parameters, semicolon);
   accept(ASTVisitor visitor) => visitor.visitFunctionTypeAlias(this);
-  /**
-   * Return the {@link TypeAliasElement} associated with this type alias, or {@code null} if the AST
-   * structure has not been resolved.
-   * @return the {@link TypeAliasElement} associated with this type alias
-   */
   TypeAliasElement get element => _name != null ? (_name.element as TypeAliasElement) : null;
   /**
    * Return the name of the function type being declared.
    * @return the name of the function type being declared
    */
   SimpleIdentifier get name => _name;
   /**
    * Return the parameters associated with the function type.
    * @return the parameters associated with the function type
    */
@@ skipping 173 matching lines @@
  */
 abstract class Identifier extends Expression {
   /**
    * Return {@code true} if the given name is visible only within the library in which it is
    * declared.
    * @param name the name being tested
    * @return {@code true} if the given name is private
    */
   static bool isPrivateName(String name) => name.startsWith("_");
   /**
-   * The element associated with this identifier, or {@code null} if the AST structure has not been
-   * resolved or if this identifier could not be resolved.
-   */
-  Element _element;
-  /**
    * Return the element associated with this identifier, or {@code null} if the AST structure has
    * not been resolved or if this identifier could not be resolved. One example of the latter case
    * is an identifier that is not defined within the scope in which it appears.
    * @return the element associated with this identifier
    */
-  Element get element => _element;
+  Element get element;
   /**
    * Return the lexical representation of the identifier.
    * @return the lexical representation of the identifier
    */
   String get name;
   bool isAssignable() => true;
-  /**
-   * Set the element associated with this identifier to the given element.
-   * @param element the element associated with this identifier
-   */
-  void set element(Element element11) {
-    this._element = element11;
-  }
 }
 /**
  * Instances of the class {@code IfStatement} represent an if statement.
  * <pre>
  * ifStatement ::=
  * 'if' '(' {@link Expression expression} ')' {@link Statement thenStatement} ('else' {@link Statement elseStatement})?
  * </pre>
  */
 class IfStatement extends Statement {
   /**
@@ skipping 324 matching lines @@
    */
   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_56_impl(target3, leftBracket4, index2, rightBracket4);
+    _jtd_constructor_57_impl(target3, leftBracket4, index2, rightBracket4);
   }
   /**
    * 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_56_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
+  _jtd_constructor_57_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
     this._target = becomeParentOf(target3);
     this._leftBracket = leftBracket4;
     this._index = becomeParentOf(index2);
     this._rightBracket = rightBracket4;
   }
   /**
    * 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_57_impl(period7, leftBracket5, index3, rightBracket5);
+    _jtd_constructor_58_impl(period7, leftBracket5, index3, rightBracket5);
   }
   /**
    * 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_57_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
+  _jtd_constructor_58_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
     this._period = period7;
     this._leftBracket = leftBracket5;
     this._index = becomeParentOf(index3);
     this._rightBracket = rightBracket5;
   }
   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
@@ skipping 57 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 parent3 = parent;
-    if (parent3 is AssignmentExpression) {
-      AssignmentExpression assignment = (parent3 as AssignmentExpression);
+    ASTNode parent4 = parent;
+    if (parent4 is AssignmentExpression) {
+      AssignmentExpression assignment = parent4 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 parent4 = parent;
-    if (parent4 is PrefixExpression) {
-      return ((parent4 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent4 is PostfixExpression) {
+    ASTNode parent5 = parent;
+    if (parent5 is PrefixExpression) {
+      return ((parent5 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent5 is PostfixExpression) {
       return true;
-    } else if (parent4 is AssignmentExpression) {
-      return identical(((parent4 as AssignmentExpression)).leftHandSide, this);
+    } else if (parent5 is AssignmentExpression) {
+      return identical(((parent5 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 element12) {
-    this._element = element12;
+  void set element(MethodElement element11) {
+    this._element = element11;
   }
   /**
    * 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.
@@ skipping 82 matching lines @@
    * @return the element associated with the constructor
    */
   ConstructorElement get element => _element;
   Token get endToken => _argumentList.endToken;
   /**
    * Return the keyword used to indicate how an object should be created.
    * @return the keyword used to indicate how an object should be created
    */
   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);
   }
   /**
    * 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;
   }
   /**
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
-  void set element(ConstructorElement element13) {
-    this._element = element13;
+  void set element(ConstructorElement element12) {
+    this._element = element12;
   }
   /**
    * 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 keyword12) {
     this._keyword = keyword12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
@@ skipping 372 matching lines @@
    * 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;
   }
   /**
    * Set the label being associated with the statement to the given label.
    * @param label the label being associated with the statement
    */
-  void set label(SimpleIdentifier label2) {
-    this._label = becomeParentOf(label2);
+  void set label(SimpleIdentifier label3) {
+    this._label = becomeParentOf(label3);
   }
   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 163 matching lines @@
    * @param components the components of the identifier
    */
   LibraryIdentifier({List<SimpleIdentifier> components}) : this.full(components);
   accept(ASTVisitor visitor) => visitor.visitLibraryIdentifier(this);
   Token get beginToken => _components.beginToken;
   /**
    * Return the components of the identifier.
    * @return the components of the identifier
    */
   NodeList<SimpleIdentifier> get components => _components;
+  Element get element => null;
   Token get endToken => _components.endToken;
   String get name {
     StringBuffer builder = new StringBuffer();
     bool needsPeriod = false;
     for (SimpleIdentifier identifier in _components) {
       if (needsPeriod) {
-        builder.add(".");
+        builder.write(".");
       } else {
         needsPeriod = true;
       }
-      builder.add(identifier.name);
+      builder.write(identifier.name);
     }
     return builder.toString();
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _components.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ListLiteral} represent a list literal.
  * <pre>
@@ skipping 266 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 /**
  * Instances of the class {@code MethodDeclaration} represent a method declaration.
  * <pre>
  * methodDeclaration ::=
  * methodSignature {@link FunctionBody body}methodSignature ::=
- * 'external'? ('abstract' | 'static')? {@link Type returnType}? ('get' | 'set')? methodName{@link FormalParameterList formalParameterList}methodName ::={@link SimpleIdentifier name} ('.' {@link SimpleIdentifier name})?
- * | 'operator' {@link SimpleIdentifier operator}</pre>
+ * 'external'? ('abstract' | 'static')? {@link Type returnType}? ('get' | 'set')? methodName{@link FormalParameterList formalParameterList}methodName ::={@link SimpleIdentifier name}| 'operator' {@link SimpleIdentifier operator}</pre>
  */
 class MethodDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or {@code null} if the constructor is not external.
    */
   Token _externalKeyword;
   /**
    * The token representing the 'abstract' or 'static' keyword, or {@code null} if neither modifier
    * was specified.
    */
   Token _modifierKeyword;
   /**
    * The return type of the method, or {@code null} if no return type was declared.
    */
   TypeName _returnType;
   /**
    * The token representing the 'get' or 'set' keyword, or {@code null} if this is a method
    * declaration rather than a property declaration.
    */
   Token _propertyKeyword;
   /**
    * The token representing the 'operator' keyword, or {@code null} if this method does not declare
    * an operator.
    */
   Token _operatorKeyword;
   /**
    * The name of the method.
    */
-  Identifier _name;
+  SimpleIdentifier _name;
   /**
    * The parameters associated with the method, or {@code null} if this method declares a getter.
    */
   FormalParameterList _parameters;
   /**
    * The body of the method.
    */
   FunctionBody _body;
   /**
    * Initialize a newly created method declaration.
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this method
    * @param metadata the annotations associated with this method
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
    * @param parameters the parameters associated with the method, or {@code null} if this method
    * declares a getter
    * @param body the body of the method
    */
-  MethodDeclaration.full(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, Identifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
+  MethodDeclaration.full(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
     this._externalKeyword = externalKeyword;
     this._modifierKeyword = modifierKeyword;
     this._returnType = becomeParentOf(returnType);
     this._propertyKeyword = propertyKeyword;
     this._operatorKeyword = operatorKeyword;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
   /**
    * Initialize a newly created method declaration.
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this method
    * @param metadata the annotations associated with this method
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
    * @param parameters the parameters associated with the method, or {@code null} if this method
    * declares a getter
    * @param body the body of the method
    */
-  MethodDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, Identifier name, FormalParameterList parameters, FunctionBody body}) : this.full(comment, metadata, externalKeyword, modifierKeyword, returnType, propertyKeyword, operatorKeyword, name, parameters, body);
+  MethodDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body}) : this.full(comment, metadata, externalKeyword, modifierKeyword, returnType, propertyKeyword, operatorKeyword, name, parameters, body);
   accept(ASTVisitor visitor) => visitor.visitMethodDeclaration(this);
   /**
    * Return the body of the method.
    * @return the body of the method
    */
   FunctionBody get body => _body;
   /**
    * Return the element associated with this method, or {@code null} if the AST structure has not
    * been resolved. The element can either be a {@link MethodElement}, if this represents the
    * declaration of a normal method, or a {@link PropertyAccessorElement} if this represents the
@@ skipping 11 matching lines @@
   /**
    * Return the token representing the 'abstract' or 'static' keyword, or {@code null} if neither
    * modifier was specified.
    * @return the token representing the 'abstract' or 'static' keyword
    */
   Token get modifierKeyword => _modifierKeyword;
   /**
    * Return the name of the method.
    * @return the name of the method
    */
-  Identifier get name => _name;
+  SimpleIdentifier get name => _name;
   /**
    * Return the token representing the 'operator' keyword, or {@code null} if this method does not
    * declare an operator.
    * @return the token representing the 'operator' keyword
    */
   Token get operatorKeyword => _operatorKeyword;
   /**
    * Return the parameters associated with the method, or {@code null} if this method declares a
    * getter.
    * @return the parameters associated with the method
    */
   FormalParameterList get parameters => _parameters;
   /**
    * Return the token representing the 'get' or 'set' keyword, or {@code null} if this is a method
    * declaration rather than a property declaration.
    * @return the token representing the 'get' or 'set' keyword
    */
   Token get propertyKeyword => _propertyKeyword;
   /**
    * Return the return type of the method, or {@code null} if no return type was declared.
    * @return the return type of the method
    */
   TypeName get returnType => _returnType;
   /**
+   * Return {@code true} if this method is declared to be an abstract method.
+   * @return {@code true} if this method is declared to be an abstract method
+   */
+  bool isAbstract() => _modifierKeyword != null && identical(((_modifierKeyword as KeywordToken)).keyword, Keyword.ABSTRACT);
+  /**
    * Return {@code true} if this method declares a getter.
    * @return {@code true} if this method declares a getter
    */
   bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
   /**
    * Return {@code true} if this method declares an operator.
    * @return {@code true} if this method declares an operator
    */
   bool isOperator() => _operatorKeyword != null;
   /**
    * Return {@code true} if this method declares a setter.
    * @return {@code true} if this method declares a setter
    */
   bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
   /**
+   * Return {@code true} if this method is declared to be a static method.
+   * @return {@code true} if this method is declared to be a static method
+   */
+  bool isStatic() => _modifierKeyword != null && identical(((_modifierKeyword as KeywordToken)).keyword, Keyword.STATIC);
+  /**
    * 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;
   }
   /**
    * 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(Identifier identifier) {
+  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;
   }
   /**
@@ skipping 203 matching lines @@
     this._expression = becomeParentOf(expression);
   }
   /**
    * Initialize a newly created named expression.
    * @param name the name associated with the expression
    * @param expression the expression with which the name is associated
    */
   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 element19 = _name.label.element;
+    if (element19 is ParameterElement) {
+      return element19 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
    */
@@ skipping 129 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 parent5 = parent;
-    if (parent5 is DefaultFormalParameter) {
-      return ((parent5 as DefaultFormalParameter)).kind;
+    ASTNode parent6 = parent;
+    if (parent6 is DefaultFormalParameter) {
+      return ((parent6 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 is a const parameter.
    * @return {@code true} if this parameter is a const parameter
    */
   bool isConst();
   /**
    * Return {@code true} if this parameter is a final parameter.
    * @return {@code true} if this parameter is a final parameter
    */
   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);
   }
   /**
    * 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 identifier6) {
-    this._identifier = becomeParentOf(identifier6);
+  void set identifier(SimpleIdentifier identifier8) {
+    this._identifier = becomeParentOf(identifier8);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 368 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 element14) {
-    this._element = element14;
+  void set element(MethodElement element13) {
+    this._element = element13;
   }
   /**
    * 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.
@@ skipping 57 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 element15) {
-    this._element = element15;
+  void set element(MethodElement element14) {
+    this._element = element14;
   }
   /**
    * 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.
@@ skipping 39 matching lines @@
   }
   /**
    * Initialize a newly created prefixed identifier.
    * @param prefix the identifier being prefixed
    * @param period the period used to separate the prefix from the identifier
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
   PrefixedIdentifier({SimpleIdentifier prefix, Token period, SimpleIdentifier identifier}) : this.full(prefix, period, identifier);
   accept(ASTVisitor visitor) => visitor.visitPrefixedIdentifier(this);
   Token get beginToken => _prefix.beginToken;
+  Element get element {
+    if (_identifier == null) {
+      return null;
+    }
+    return _identifier.element;
+  }
   Token get endToken => _identifier.endToken;
   /**
    * Return the identifier being prefixed.
    * @return the identifier being prefixed
    */
   SimpleIdentifier get identifier => _identifier;
   String get name => "${_prefix.name}.${_identifier.name}";
   /**
    * Return the period used to separate the prefix from the identifier.
    * @return the period used to separate the prefix from the identifier
    */
   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 identifier7) {
-    this._identifier = becomeParentOf(identifier7);
+  void set identifier(SimpleIdentifier identifier9) {
+    this._identifier = becomeParentOf(identifier9);
   }
   /**
    * 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;
   }
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
@@ skipping 221 matching lines @@
    * 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 element16) {
-    this._element = element16;
+  void set element(ConstructorElement element15) {
+    this._element = element15;
   }
   /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
   void set keyword(Token keyword13) {
     this._keyword = keyword13;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
@@ skipping 262 matching lines @@
  * initialCharacter ::= '_' | '$' | letter
  * internalCharacter ::= '_' | '$' | letter | digit
  * </pre>
  */
 class SimpleIdentifier extends Identifier {
   /**
    * The token representing the identifier.
    */
   Token _token;
   /**
+   * The element associated with this identifier, or {@code null} if the AST structure has not been
+   * resolved or if this identifier could not be resolved.
+   */
+  Element _element;
+  /**
    * Initialize a newly created identifier.
    * @param token the token representing the identifier
    */
   SimpleIdentifier.full(Token token) {
     this._token = token;
   }
   /**
    * Initialize a newly created identifier.
    * @param token the token representing the identifier
    */
   SimpleIdentifier({Token token}) : this.full(token);
   accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
   Token get beginToken => _token;
+  Element get element => _element;
   Token get endToken => _token;
   String get name => _token.lexeme;
   /**
    * 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;
+      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 NormalFormalParameter) {
+      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);
+    }
+    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 parent6 = parent;
+    ASTNode parent8 = parent;
     ASTNode target = this;
-    if (parent6 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = (parent6 as PrefixedIdentifier);
+    if (parent8 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent8 as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
-      parent6 = prefixed.parent;
+      parent8 = prefixed.parent;
       target = prefixed;
+    } else if (parent8 is PropertyAccess) {
+      PropertyAccess access = parent8 as PropertyAccess;
+      if (identical(access.target, this)) {
+        return true;
+      }
+      parent8 = access.parent;
+      target = access;
     }
-    if (parent6 is AssignmentExpression) {
-      AssignmentExpression expr = (parent6 as AssignmentExpression);
+    if (parent8 is AssignmentExpression) {
+      AssignmentExpression expr = parent8 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 parent7 = parent;
+    ASTNode parent9 = parent;
     ASTNode target = this;
-    if (parent7 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = (parent7 as PrefixedIdentifier);
+    if (parent9 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent9 as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return false;
       }
-      parent7 = prefixed.parent;
+      parent9 = prefixed.parent;
       target = prefixed;
+    } else if (parent9 is PropertyAccess) {
+      PropertyAccess access = parent9 as PropertyAccess;
+      if (identical(access.target, this)) {
+        return false;
+      }
+      parent9 = access.parent;
+      target = access;
     }
-    if (parent7 is PrefixExpression) {
-      return ((parent7 as PrefixExpression)).operator.type.isIncrementOperator();
-    } else if (parent7 is PostfixExpression) {
+    if (parent9 is PrefixExpression) {
+      return ((parent9 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent9 is PostfixExpression) {
       return true;
-    } else if (parent7 is AssignmentExpression) {
-      return identical(((parent7 as AssignmentExpression)).leftHandSide, target);
+    } else if (parent9 is AssignmentExpression) {
+      return identical(((parent9 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;
+  }
+  /**
    * Set the token representing the identifier to the given token.
    * @param token the token representing the literal
    */
   void set token(Token token12) {
     this._token = token12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
@@ skipping 776 matching lines @@
   }
   /**
    * Initialize a newly created top-level variable declaration.
    * @param comment the documentation comment associated with this variable
    * @param metadata the annotations associated with this variable
    * @param variableList the top-level variables being declared
    * @param semicolon the semicolon terminating the declaration
    */
   TopLevelVariableDeclaration({Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon}) : this.full(comment, metadata, variableList, semicolon);
   accept(ASTVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
+  Element get element => null;
   Token get endToken => _semicolon;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Return the top-level variables being declared.
    * @return the top-level variables being declared
    */
@@ skipping 418 matching lines @@
    * @param bound the name of the upper bound for legal arguments
    */
   TypeParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound}) : this.full(comment, metadata, name, keyword, bound);
   accept(ASTVisitor visitor) => visitor.visitTypeParameter(this);
   /**
    * Return the name of the upper bound for legal arguments, or {@code null} if there was no
    * explicit upper bound.
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
+  TypeVariableElement get element => _name != null ? (_name.element as TypeVariableElement) : null;
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
   /**
    * Return the token representing the 'assert' keyword.
    * @return the token representing the 'assert' keyword
    */
@@ skipping 237 matching lines @@
   /**
    * Initialize a newly created variable declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this member
    * @param name the name of the variable being declared
    * @param equals the equal sign separating the variable name from the initial value
    * @param initializer the expression used to compute the initial value for the variable
    */
   VariableDeclaration({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token equals, Expression initializer}) : this.full(comment, metadata, name, equals, initializer);
   accept(ASTVisitor visitor) => visitor.visitVariableDeclaration(this);
-  /**
-   * Return the {@link VariableElement} associated with this variable, or {@code null} if the AST
-   * structure has not been resolved.
-   * @return the {@link VariableElement} associated with this variable
-   */
   VariableElement get element => _name != null ? (_name.element as VariableElement) : null;
   Token get endToken {
     if (_initializer != null) {
       return _initializer.endToken;
     }
     return _name.endToken;
   }
   /**
    * Return the equal sign separating the variable name from the initial value, or {@code null} if
    * the initial value was not specified.
    * @return the equal sign separating the variable name from the initial value
    */
   Token get equals => _equals;
   /**
    * Return the expression used to compute the initial value for the variable, or {@code null} if
    * the initial value was not specified.
    * @return the expression used to compute the initial value for the variable
    */
   Expression get initializer => _initializer;
   /**
    * 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 declaration is declared to be a const variable.
+   * @return {@code true} if this variable is declared to be a const variable
+   */
+  bool isConst() {
+    ASTNode parent10 = parent;
+    return parent10 is VariableDeclarationList && ((parent10 as VariableDeclarationList)).isConst();
+  }
+  /**
+   * Return {@code true} if this variable declaration is declared to be a final variable.
+   * @return {@code true} if this variable is declared to be a final variable
+   */
+  bool isFinal() {
+    ASTNode parent11 = parent;
+    return parent11 is VariableDeclarationList && ((parent11 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;
   }
   /**
    * 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
    */
@@ skipping 79 matching lines @@
    * Return the type of the variables being declared, or {@code null} if no type was provided.
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
   /**
    * Return a list containing the individual variables being declared.
    * @return a list containing the individual variables being declared
    */
   NodeList<VariableDeclaration> get variables => _variables;
   /**
+   * Return {@code true} if the variable declarations in this list are declared to be const
+   * variables.
+   * @return {@code true} if the variables in this list are declared to be const variables
+   */
+  bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  /**
+   * Return {@code true} if the variable declarations in this list are declared to be final
+   * variables.
+   * @return {@code true} if the variables in this list are declared to be final variables
+   */
+  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 keyword24) {
     this._keyword = keyword24;
   }
   /**
    * Set the type of the variables being declared to the given type name.
    * @param typeName the type of the variables being declared
    */
@@ skipping 280 matching lines @@
    * expressions.
    */
   static Object NOT_A_CONSTANT = new Object();
   Object visitAdjacentStrings(AdjacentStrings node) {
     StringBuffer builder = new StringBuffer();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.add(value);
+      builder.write(value);
     }
     return builder.toString();
   }
   Object visitBinaryExpression(BinaryExpression node) {
     Object leftOperand2 = node.leftOperand.accept(this);
     if (identical(leftOperand2, NOT_A_CONSTANT)) {
       return leftOperand2;
     }
     Object rightOperand2 = node.rightOperand.accept(this);
     if (identical(rightOperand2, NOT_A_CONSTANT)) {
       return rightOperand2;
     }
-    if (node.operator.type == TokenType.AMPERSAND) {
-      if (leftOperand2 is int && rightOperand2 is int) {
-        return ((leftOperand2 as int)) & (rightOperand2 as int);
+    while (true) {
+      if (node.operator.type == TokenType.AMPERSAND) {
+        if (leftOperand2 is int && rightOperand2 is int) {
+          return ((leftOperand2 as int)) & (rightOperand2 as int);
+        }
+      } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
+        if (leftOperand2 is bool && rightOperand2 is bool) {
+          return ((leftOperand2 as bool)) && ((rightOperand2 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;
+        }
+      } else if (node.operator.type == TokenType.BAR) {
+        if (leftOperand2 is int && rightOperand2 is int) {
+          return ((leftOperand2 as int)) | (rightOperand2 as int);
+        }
+      } else if (node.operator.type == TokenType.BAR_BAR) {
+        if (leftOperand2 is bool && rightOperand2 is bool) {
+          return ((leftOperand2 as bool)) || ((rightOperand2 as bool));
+        }
+      } else if (node.operator.type == TokenType.CARET) {
+        if (leftOperand2 is int && rightOperand2 is int) {
+          return ((leftOperand2 as int)) ^ (rightOperand2 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;
+        }
+      } 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;
+        }
+      } 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;
+        }
+      } else if (node.operator.type == TokenType.GT_GT) {
+        if (leftOperand2 is int && rightOperand2 is int) {
+          return ((leftOperand2 as int)) >> ((rightOperand2 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;
+        }
+      } 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;
+        }
+      } else if (node.operator.type == TokenType.LT_LT) {
+        if (leftOperand2 is int && rightOperand2 is int) {
+          return ((leftOperand2 as int)) << ((rightOperand2 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));
+        }
+      } 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));
+        }
+      } 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));
+        }
+      } 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));
+        }
+      } else if (node.operator.type == TokenType.SLASH) {
+        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));
+        }
+      } else if (node.operator.type == TokenType.TILDE_SLASH) {
+        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));
+        }
       }
-    } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
-      if (leftOperand2 is bool && rightOperand2 is bool) {
-        return ((leftOperand2 as bool)) && ((rightOperand2 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;
-      }
-    } else if (node.operator.type == TokenType.BAR) {
-      if (leftOperand2 is int && rightOperand2 is int) {
-        return ((leftOperand2 as int)) | (rightOperand2 as int);
-      }
-    } else if (node.operator.type == TokenType.BAR_BAR) {
-      if (leftOperand2 is bool && rightOperand2 is bool) {
-        return ((leftOperand2 as bool)) || ((rightOperand2 as bool));
-      }
-    } else if (node.operator.type == TokenType.CARET) {
-      if (leftOperand2 is int && rightOperand2 is int) {
-        return ((leftOperand2 as int)) ^ (rightOperand2 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;
-      }
-    } 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;
-      }
-    } 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;
-      }
-    } else if (node.operator.type == TokenType.GT_GT) {
-      if (leftOperand2 is int && rightOperand2 is int) {
-        return ((leftOperand2 as int)) >> ((rightOperand2 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;
-      }
-    } 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;
-      }
-    } else if (node.operator.type == TokenType.LT_LT) {
-      if (leftOperand2 is int && rightOperand2 is int) {
-        return ((leftOperand2 as int)) << ((rightOperand2 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));
-      }
-    } 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));
-      }
-    } 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));
-      }
-    } 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));
-      }
-    } else if (node.operator.type == TokenType.SLASH) {
-      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));
-      }
-    } else if (node.operator.type == TokenType.TILDE_SLASH) {
-      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));
-      }
+      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) {
     Object value = node.expression.accept(this);
     if (value == null || value is bool || value is String || value is int || value is double) {
       return value;
     }
     return NOT_A_CONSTANT;
   }
   Object visitInterpolationString(InterpolationString node) => node.value;
   Object visitListLiteral(ListLiteral node) {
     List<Object> list = new List<Object>();
     for (Expression element in node.elements) {
       Object value = element.accept(this);
       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 value7 = entry.value.accept(this);
-      if (key2 is! String || identical(value7, NOT_A_CONSTANT)) {
+      Object value8 = entry.value.accept(this);
+      if (key2 is! String || identical(value8, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
-      map[(key2 as String)] = value7;
+      map[(key2 as String)] = value8;
     }
     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;
     }
-    if (node.operator.type == TokenType.BANG) {
-      if (identical(operand2, true)) {
-        return false;
-      } else if (identical(operand2, false)) {
-        return true;
+    while (true) {
+      if (node.operator.type == TokenType.BANG) {
+        if (identical(operand2, true)) {
+          return false;
+        } else if (identical(operand2, false)) {
+          return true;
+        }
+      } else if (node.operator.type == TokenType.TILDE) {
+        if (operand2 is int) {
+          return ~((operand2 as int));
+        }
+      } else if (node.operator.type == TokenType.MINUS) {
+        if (operand2 == null) {
+          return null;
+        } else if (operand2 is int) {
+          return -((operand2 as int));
+        } else if (operand2 is double) {
+          return -((operand2 as double));
+        }
       }
-    } else if (node.operator.type == TokenType.TILDE) {
-      if (operand2 is int) {
-        return ~((operand2 as int));
-      }
-    } else if (node.operator.type == TokenType.MINUS) {
-      if (operand2 == null) {
-        return null;
-      } else if (operand2 is int) {
-        return -((operand2 as int));
-      } else if (operand2 is double) {
-        return -((operand2 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) {
     StringBuffer builder = new StringBuffer();
     for (InterpolationElement element in node.elements) {
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.add(value);
+      builder.write(value);
     }
     return builder.toString();
   }
   /**
    * Return the constant value of the static constant represented by the given element.
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
-      FieldElement field = (element as FieldElement);
+      FieldElement field = element as FieldElement;
       if (field.isStatic() && field.isConst()) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 /**
+ * Instances of the class {@code ElementLocator} locate the {@link Element Dart model element}associated with a given {@link ASTNode AST node}.
+ */
+class ElementLocator {
+  /**
+   * Locate the {@link Element Dart model element} associated with the given {@link ASTNode AST
+   * node}.
+   * @param node the node (not {@code null})
+   * @return the associated element, or {@code null} if none is found
+   */
+  static Element locate(ASTNode node) {
+    ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
+    return node.accept(mapper);
+  }
+  /**
+   * Clients should use {@link #locate(ASTNode)}.
+   */
+  ElementLocator() {
+  }
+}
+/**
+ * Visitor that maps nodes to elements.
+ */
+class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
+  Element visitBinaryExpression(BinaryExpression node) => node.element;
+  Element visitIdentifier(Identifier node) => node.element;
+  Element visitImportDirective(ImportDirective node) => node.element;
+  Element visitIndexExpression(IndexExpression node) => node.element;
+  Element visitLibraryDirective(LibraryDirective node) => node.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;
+    }
+    return null;
+  }
+}
+/**
  * 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
  * visit a {@link Block} will cause the method {@link #visitBlock(Block)} to be invoked but will
  * also cause the methods {@link #visitStatement(Statement)} and {@link #visitNode(ASTNode)} to be
  * subsequently invoked. This allows visitors to be written that visit all statements without
  * needing to override the visit method for each of the specific subclasses of {@link Statement}.
  * <p>
  * Subclasses that override a visit method must either invoke the overridden visit method or
@@ skipping 70 matching lines @@
   R visitIsExpression(IsExpression node) => visitExpression(node);
   R visitLabel(Label node) => visitNode(node);
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDirective(LibraryDirective node) => visitDirective(node);
   R visitLibraryIdentifier(LibraryIdentifier node) => visitIdentifier(node);
   R visitListLiteral(ListLiteral node) => visitTypedLiteral(node);
   R visitLiteral(Literal node) => visitExpression(node);
   R visitMapLiteral(MapLiteral node) => visitTypedLiteral(node);
   R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
   R visitMethodDeclaration(MethodDeclaration node) => visitClassMember(node);
-  R visitMethodInvocation(MethodInvocation node) => visitNode(node);
+  R visitMethodInvocation(MethodInvocation node) => visitExpression(node);
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
   R visitNamespaceDirective(NamespaceDirective node) => visitUriBasedDirective(node);
   R visitNode(ASTNode node) {
     node.visitChildren(this);
     return null;
   }
   R visitNormalFormalParameter(NormalFormalParameter node) => visitFormalParameter(node);
   R visitNullLiteral(NullLiteral node) => visitLiteral(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitExpression(node);
   R visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
@@ skipping 54 matching lines @@
    * The element that was found that corresponds to the given source range, or {@code null} if there
    * is no such element.
    */
   ASTNode _foundNode;
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given offset in the source.
    * @param offset the offset used to identify the node
    */
   NodeLocator.con1(int offset) {
-    _jtd_constructor_114_impl(offset);
+    _jtd_constructor_116_impl(offset);
   }
-  _jtd_constructor_114_impl(int offset) {
-    _jtd_constructor_115_impl(offset, offset);
+  _jtd_constructor_116_impl(int offset) {
+    _jtd_constructor_117_impl(offset, offset);
   }
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given range of characters in the
    * source.
    * @param start the start offset of the range used to identify the node
    * @param end the end offset of the range used to identify the node
    */
   NodeLocator.con2(int start, int end) {
-    _jtd_constructor_115_impl(start, end);
+    _jtd_constructor_117_impl(start, end);
   }
-  _jtd_constructor_115_impl(int start, int end) {
+  _jtd_constructor_117_impl(int start, int end) {
     this._startOffset = start;
     this._endOffset = end;
   }
   /**
    * Return the node that was found that corresponds to the given source range, or {@code null} if
    * there is no such node.
    * @return the node that was found
    */
   ASTNode get foundNode => _foundNode;
   /**
@@ skipping 1373 matching lines @@
     for (E element in elements) {
       element.accept(visitor);
     }
   }
   void add(E node) {
     owner.becomeParentOf(node);
     elements.add(node);
   }
   bool addAll(Collection<E> nodes) {
     if (nodes != null) {
-      super.addAll(nodes);
+      for (E node in nodes) {
+        add(node);
+      }
       return true;
     }
     return false;
   }
   /**
    * Return the first token included in this node's source range.
    * @return the first token included in this node's source range
    */
   Token get beginToken {
     if (elements.isEmpty) {
@@ skipping 12 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;
   }
 }