New analyzer_experimental snapshot.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 33 matching lines @@
 
   /**
    * 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 [ASTNode] of given [Class] which is [ASTNode] itself, or one of
-   *         its parents.
+   * Return the node of the given class that most immediately encloses this node, or `null` if
+   * there is no enclosing node of the given class.
+   *
+   * @param nodeClass the class of the node to be returned
+   * @return the node of the given type that encloses this node
    */
   ASTNode getAncestor(Type enclosingClass) {
     ASTNode node = this;
     while (node != null && !isInstanceOf(node, enclosingClass)) {
       node = node.parent;
     }
     ;
     return node as ASTNode;
   }
 
@@ skipping 873 matching lines @@
   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 `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) {
+  void set correspondingPropagatedParameters(List<ParameterElement> parameters) {
     if (parameters.length != _arguments.length) {
       throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingPropagatedParameters = parameters;
   }
 
   /**
    * 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 `null` entries if a given argument does not correspond to a
@@ skipping 29 matching lines @@
     _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 based on propagated type information, 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 `null`.
    *
-   * This method is only intended to be used by [Expression#getParameterElement].
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @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 getPropagatedParameterElementFor(Expression expression) {
     if (_correspondingPropagatedParameters == null) {
       return null;
     }
     int index = _arguments.indexOf(expression);
@@ skipping 71 matching lines @@
    * Initialize a newly created as expression.
    *
    * @param expression the expression used to compute the value being cast
    * @param isOperator the is operator
    * @param type the name of the type being cast to
    */
   AsExpression({Expression expression, Token isOperator, TypeName type}) : this.full(expression, isOperator, type);
   accept(ASTVisitor visitor) => visitor.visitAsExpression(this);
 
   /**
-   * Return the is operator being applied.
+   * Return the as operator being applied.
    *
-   * @return the is operator being applied
+   * @return the as operator being applied
    */
   Token get asOperator => _asOperator;
   Token get beginToken => _expression.beginToken;
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value being cast.
    *
    * @return the expression used to compute the value being cast
    */
@@ skipping 247 matching lines @@
    *
    * @param leftHandSide the expression used to compute the left hand side
    * @param operator the assignment operator being applied
    * @param rightHandSide the expression used to compute the right hand side
    */
   AssignmentExpression({Expression leftHandSide, Token operator, Expression rightHandSide}) : this.full(leftHandSide, operator, rightHandSide);
   accept(ASTVisitor visitor) => visitor.visitAssignmentExpression(this);
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the
-   * left-hand-side, or `null` if the AST structure has not been resolved, if the operator is
-   * not a compound operator, or if the operator could not be resolved. One example of the latter
-   * case is an operator that is not defined for the type of the left-hand operand.
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
    *
-   * @return the element associated with the operator
+   * @return the best element available for this operator
    */
-  MethodElement get element => _propagatedElement;
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _rightHandSide.endToken;
 
   /**
    * Set the expression used to compute the left hand side to the given expression.
    *
    * @return the expression used to compute the left hand side
    */
   Expression get leftHandSide => _leftHandSide;
 
   /**
    * Return the assignment operator being applied.
    *
    * @return the assignment operator being applied
    */
   Token get operator => _operator;
 
   /**
+   * Return the element associated with the operator based on the propagated type of the
+   * left-hand-side, or `null` if the AST structure has not been resolved, if the operator is
+   * not a compound operator, or if the operator could not be resolved. One example of the latter
+   * case is an operator that is not defined for the type of the left-hand operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the expression used to compute the right hand side.
    *
    * @return the expression used to compute the right hand side
    */
   Expression get rightHandSide => _rightHandSide;
 
   /**
    * Return the element associated with the operator based on the static type of the left-hand-side,
    * or `null` if the AST structure has not been resolved, if the operator is not a compound
    * operator, or if the operator could not be resolved. One example of the latter case is an
    * operator that is not defined for the type of the left-hand operand.
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
-   * Set the element associated with the operator based on the propagated type of the left-hand-side
-   * to the given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set element(MethodElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Return the expression used to compute the left hand side.
    *
    * @param expression the expression used to compute the left hand side
    */
   void set leftHandSide(Expression expression) {
     _leftHandSide = becomeParentOf(expression);
   }
 
   /**
    * Set the assignment operator being applied to the given operator.
    *
    * @param operator the assignment operator being applied
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
 
   /**
+   * Set the element associated with the operator based on the propagated type of the left-hand-side
+   * to the given element.
+   *
+   * @param element the element to be associated with the operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the expression used to compute the left hand side to the given expression.
    *
    * @param expression the expression used to compute the left hand side
    */
   void set rightHandSide(Expression expression) {
     _rightHandSide = becomeParentOf(expression);
   }
 
   /**
    * Set the element associated with the operator based on the static type of the left-hand-side to
    * the given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   *
+   * @return the parameter element representing the parameter to which the value of the right
+   *         operand will be bound
+   */
+  ParameterElement get propagatedParameterElementForRightHandSide {
+    if (_propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   *
+   * @return the parameter element representing the parameter to which the value of the right
+   *         operand will be bound
+   */
+  ParameterElement get staticParameterElementForRightHandSide {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
 }
 /**
  * Instances of the class `BinaryExpression` represent a binary (infix) expression.
  *
  * <pre>
  * binaryExpression ::=
  *     [Expression] [Token] [Expression]
  * </pre>
  *
  * @coverage dart.engine.ast
@@ skipping 47 matching lines @@
    *
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
   BinaryExpression({Expression leftOperand, Token operator, Expression rightOperand}) : this.full(leftOperand, operator, rightOperand);
   accept(ASTVisitor visitor) => visitor.visitBinaryExpression(this);
   Token get beginToken => _leftOperand.beginToken;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the left
-   * operand, or `null` if the AST structure has not been resolved, if the operator is not
-   * user definable, or if the operator could not be resolved. One example of the latter case is an
-   * operator that is not defined for the type of the left-hand operand.
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
    *
-   * @return the element associated with the operator
+   * @return the best element available for this operator
    */
-  MethodElement get element => _propagatedElement;
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _rightOperand.endToken;
 
   /**
    * Return the expression used to compute the left operand.
    *
    * @return the expression used to compute the left operand
    */
   Expression get leftOperand => _leftOperand;
 
   /**
    * Return the binary operator being applied.
    *
    * @return the binary operator being applied
    */
   Token get operator => _operator;
 
   /**
+   * Return the element associated with the operator based on the propagated type of the left
+   * operand, or `null` if the AST structure has not been resolved, if the operator is not
+   * user definable, or if the operator could not be resolved. One example of the latter case is an
+   * operator that is not defined for the type of the left-hand operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the expression used to compute the right operand.
    *
    * @return the expression used to compute the right operand
    */
   Expression get rightOperand => _rightOperand;
 
   /**
    * Return the element associated with the operator based on the static type of the left operand,
    * or `null` if the AST structure has not been resolved, if the operator is not user
    * definable, or if the operator could not be resolved. One example of the latter case is an
    * operator that is not defined for the type of the left operand.
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
-   * Set the element associated with the operator based on the propagated type of the left operand
-   * to the given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set element(MethodElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the expression used to compute the left operand to the given expression.
    *
    * @param expression the expression used to compute the left operand
    */
   void set leftOperand(Expression expression) {
     _leftOperand = becomeParentOf(expression);
   }
 
   /**
    * Set the binary operator being applied to the given operator.
    *
    * @return the binary operator being applied
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
 
   /**
+   * Set the element associated with the operator based on the propagated type of the left operand
+   * to the given element.
+   *
+   * @param element the element to be associated with the operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the expression used to compute the right operand to the given expression.
    *
    * @param expression the expression used to compute the right operand
    */
   void set rightOperand(Expression expression) {
     _rightOperand = becomeParentOf(expression);
   }
 
   /**
    * Set the element associated with the operator based on the static type of the left operand to
    * the given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getParameterElement].
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
@@ skipping 474 matching lines @@
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The parameter whose value will be the exception that was thrown.
    */
   SimpleIdentifier _exceptionParameter;
 
   /**
-   * The comma separating the exception parameter from the stack trace parameter.
+   * The comma separating the exception parameter from the stack trace parameter, or `null` if
+   * there is no stack trace parameter.
    */
   Token _comma;
 
   /**
-   * The parameter whose value will be the stack trace associated with the exception.
+   * The parameter whose value will be the stack trace associated with the exception, or
+   * `null` if there is no stack trace parameter.
    */
   SimpleIdentifier _stackTraceParameter;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * The body of the catch block.
@@ skipping 56 matching lines @@
 
   /**
    * Return the token representing the 'catch' keyword, or `null` if there is no 'catch'
    * keyword.
    *
    * @return the token representing the 'catch' keyword
    */
   Token get catchKeyword => _catchKeyword;
 
   /**
-   * Return the comma.
+   * Return the comma, or `null` if there is no stack trace parameter.
    *
    * @return the comma
    */
   Token get comma => _comma;
   Token get endToken => _body.endToken;
 
   /**
    * Return the parameter whose value will be the exception that was thrown.
    *
    * @return the parameter whose value will be the exception that was thrown
@@ skipping 23 matching lines @@
   Token get onKeyword => _onKeyword;
 
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
-   * Return the parameter whose value will be the stack trace associated with the exception.
+   * Return the parameter whose value will be the stack trace associated with the exception, or
+   * `null` if there is no stack trace parameter.
    *
    * @return the parameter whose value will be the stack trace associated with the exception
    */
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
 
   /**
    * Set the body of the catch block to the given block.
    *
    * @param block the body of the catch block
    */
@@ skipping 374 matching lines @@
   void set withClause(WithClause withClause2) {
     this._withClause = becomeParentOf(withClause2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
+    safelyVisitChild(_nativeClause, visitor);
     members.accept(visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_abstractKeyword != null) {
       return _abstractKeyword;
     }
     return _classKeyword;
   }
 }
 /**
@@ skipping 428 matching lines @@
    */
   bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
   void visitChildren(ASTVisitor<Object> visitor) {
     _references.accept(visitor);
   }
 }
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
-class CommentType implements Comparable<CommentType> {
+class CommentType implements Enum<CommentType> {
 
   /**
    * An end-of-line comment.
    */
   static final CommentType END_OF_LINE = new CommentType('END_OF_LINE', 0);
 
   /**
    * A block comment.
    */
   static final CommentType BLOCK = new CommentType('BLOCK', 1);
@@ skipping 149 matching lines @@
    */
   Token _endToken;
 
   /**
    * The element associated with this compilation unit, or `null` if the AST structure has not
    * been resolved.
    */
   CompilationUnitElement _element;
 
   /**
-   * The [LineInfo] for this [CompilationUnit].
+   * The line information for this compilation unit.
    */
   LineInfo _lineInfo;
 
   /**
    * The parsing errors encountered when the receiver was parsed.
    */
   List<AnalysisError> _parsingErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The resolution errors encountered when the receiver was resolved.
@@ skipping 49 matching lines @@
   /**
    * Return the element associated with this compilation unit, or `null` if the AST structure
    * has not been resolved.
    *
    * @return the element associated with this compilation unit
    */
   CompilationUnitElement get element => _element;
   Token get endToken => _endToken;
 
   /**
-   * Return an array containing all of the errors associated with the receiver. If the receiver has
-   * not been resolved, then return `null`.
+   * Return an array containing all of the errors associated with the receiver. The array will be
+   * empty if the receiver has not been resolved and there were no parse errors.
    *
-   * @return an array of errors (contains no `null`s) or `null` if the receiver has not
-   *         been resolved
+   * @return the errors associated with the receiver
    */
   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);
       JavaSystem.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
       JavaSystem.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
       return allErrors;
     }
   }
   int get length {
     Token endToken = this.endToken;
     if (endToken == null) {
       return 0;
     }
     return endToken.offset + endToken.length;
   }
 
   /**
-   * Get the [LineInfo] object for this compilation unit.
+   * Return the line information for this compilation unit.
    *
-   * @return the associated [LineInfo]
+   * @return the line information for this compilation unit
    */
   LineInfo get lineInfo => _lineInfo;
   int get offset => 0;
 
   /**
    * Return an array containing all of the parsing errors associated with the receiver.
    *
-   * @return an array of errors (not `null`, contains no `null`s).
+   * @return the parsing errors associated with the receiver
    */
   List<AnalysisError> get parsingErrors => _parsingErrors;
 
   /**
-   * Return an array containing all of the resolution errors associated with the receiver. If the
-   * receiver has not been resolved, then return `null`.
+   * Return an array containing all of the resolution errors associated with the receiver. The array
+   * will be empty if the receiver has not been resolved.
    *
-   * @return an array of errors (contains no `null`s) or `null` if the receiver has not
-   *         been resolved
+   * @return the resolution errors associated with the receiver
    */
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the script tag at the beginning of the compilation unit, or `null` if there is no
    * script tag in this compilation unit.
    *
    * @return the script tag at the beginning of the compilation unit
    */
   ScriptTag get scriptTag => _scriptTag;
 
   /**
    * Set the element associated with this compilation unit to the given element.
    *
    * @param element the element associated with this compilation unit
    */
   void set element(CompilationUnitElement element2) {
     this._element = element2;
   }
 
   /**
-   * Set the [LineInfo] object for this compilation unit.
+   * Set the line information for this compilation unit to the given line information.
    *
-   * @param errors LineInfo to associate with this compilation unit
+   * @param errors the line information to associate with this compilation unit
    */
   void set lineInfo(LineInfo lineInfo2) {
     this._lineInfo = lineInfo2;
   }
 
   /**
-   * Called to cache the parsing errors when the unit is parsed.
+   * Set the parse errors associated with this compilation unit to the given errors.
    *
-   * @param errors an array of parsing errors, if `null` is passed, the error array is set to
-   *          an empty array, [AnalysisError#NO_ERRORS]
+   * @param the parse errors to be associated with this compilation unit
    */
   void set parsingErrors(List<AnalysisError> errors) {
     _parsingErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
 
   /**
-   * Called to cache the resolution errors when the unit is resolved.
+   * Set the resolution errors associated with this compilation unit to the given errors.
    *
-   * @param errors an array of resolution errors, if `null` is passed, the error array is set
-   *          to an empty array, [AnalysisError#NO_ERRORS]
+   * @param the resolution errors to be associated with this compilation unit
    */
   void set resolutionErrors(List<AnalysisError> errors) {
     _resolutionErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    *
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
@@ skipping 291 matching lines @@
    * declared is unnamed.
    */
   Token _period;
 
   /**
    * The name of the constructor, or `null` if the constructor being declared is unnamed.
    */
   SimpleIdentifier _name;
 
   /**
-   * The element associated with this constructor, or `null` if the AST structure has not been
-   * resolved or if this constructor could not be resolved.
-   */
-  ConstructorElement _element;
-
-  /**
    * The parameters associated with the constructor.
    */
   FormalParameterList _parameters;
 
   /**
-   * The token for the separator (colon or equals) before the initializers, or `null` if there
-   * are no initializers.
+   * The token for the separator (colon or equals) before the initializer list or redirection, or
+   * `null` if there are no initializers.
    */
   Token _separator;
 
   /**
    * The initializers associated with the constructor.
    */
   NodeList<ConstructorInitializer> _initializers;
 
   /**
    * The name of the constructor to which this constructor will be redirected, or `null` if
    * this is not a redirecting factory constructor.
    */
   ConstructorName _redirectedConstructor;
 
   /**
    * The body of the constructor, or `null` if the constructor does not have a body.
    */
   FunctionBody _body;
 
   /**
+   * The element associated with this constructor, or `null` if the AST structure has not been
+   * resolved or if this constructor could not be resolved.
+   */
+  ConstructorElement _element;
+
+  /**
    * Initialize a newly created constructor declaration.
    *
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this constructor
    * @param metadata the annotations associated with this constructor
    * @param constKeyword the token for the 'const' keyword
    * @param factoryKeyword the token for the 'factory' keyword
    * @param returnType the return type of the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
@@ skipping 119 matching lines @@
   /**
    * Return 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.
    *
    * @return the type of object being created
    */
   Identifier get returnType => _returnType;
 
   /**
-   * Return the token for the separator (colon or equals) before the initializers, or `null`
-   * if there are no initializers.
+   * Return the token for the separator (colon or equals) before the initializer list or
+   * redirection, or `null` if there are no initializers.
    *
-   * @return the token for the separator (colon or equals) before the initializers
+   * @return the token for the separator before the initializer list or redirection
    */
   Token get separator => _separator;
 
   /**
    * Set the body of the constructor to the given function body.
    *
    * @param functionBody the body of the constructor
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
@@ skipping 668 matching lines @@
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the name of the variable being declared.
    *
    * @return the name of the variable being declared
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
-   * Return the token representing either the 'final', 'const' or 'var' keyword.
+   * Return the token representing either the 'final', 'const' or 'var' keyword, or `null` if
+   * no keyword was used.
    *
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    *
    * @return the name of the declared type of the parameter
@@ skipping 722 matching lines @@
    */
   Type2 _staticType;
 
   /**
    * The propagated type of this expression, or `null` if type propagation has not been
    * performed on the AST structure.
    */
   Type2 _propagatedType;
 
   /**
+   * Return the best type information available for this expression. If type propagation was able to
+   * find a better type than static analysis, that type will be returned. Otherwise, the result of
+   * static analysis will be returned. If no type analysis has been performed, then the type
+   * 'dynamic' will be returned.
+   *
+   * @return the best type information available for this expression
+   */
+  Type2 get bestType {
+    if (_propagatedType != null) {
+      return _propagatedType;
+    } else if (_staticType != null) {
+      return _staticType;
+    }
+    return DynamicTypeImpl.instance;
+  }
+
+  /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on propagated type information, and this
    * expression corresponds to one of the parameters of the function being invoked, then return the
    * parameter element representing the parameter to which the value of this expression will be
    * bound. Otherwise, return `null`.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
-  ParameterElement get parameterElement {
+  ParameterElement get propagatedParameterElement {
     ASTNode parent = this.parent;
     if (parent is ArgumentList) {
       return ((parent as ArgumentList)).getPropagatedParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.propagatedParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.propagatedParameterElementForRightOperand;
       }
+    } else if (parent is AssignmentExpression) {
+      AssignmentExpression assignmentExpression = parent as AssignmentExpression;
+      if (identical(assignmentExpression.rightHandSide, this)) {
+        return assignmentExpression.propagatedParameterElementForRightHandSide;
+      }
     } else if (parent is PrefixExpression) {
       return ((parent as PrefixExpression)).propagatedParameterElementForOperand;
     } else if (parent is PostfixExpression) {
       return ((parent as PostfixExpression)).propagatedParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * Return the propagated type of this expression, or `null` if type propagation has not been
@@ skipping 20 matching lines @@
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.staticParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.staticParameterElementForRightOperand;
       }
+    } else if (parent is AssignmentExpression) {
+      AssignmentExpression assignmentExpression = parent as AssignmentExpression;
+      if (identical(assignmentExpression.rightHandSide, this)) {
+        return assignmentExpression.staticParameterElementForRightHandSide;
+      }
     } else if (parent is PrefixExpression) {
       return ((parent as PrefixExpression)).staticParameterElementForOperand;
     } else if (parent is PostfixExpression) {
       return ((parent as PostfixExpression)).staticParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * Return the static type of this expression, or `null` if the AST structure has not been
@@ skipping 153 matching lines @@
  */
 class ExpressionStatement extends Statement {
 
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement, or `null` if the expression is a function
-   * expression and isn't followed by a semicolon.
+   * expression and therefore isn't followed by a semicolon.
    */
   Token _semicolon;
 
   /**
    * Initialize a newly created expression statement.
    *
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionStatement.full(Expression expression, Token semicolon) {
@@ skipping 18 matching lines @@
   }
 
   /**
    * Return the expression that comprises the statement.
    *
    * @return the expression that comprises the statement
    */
   Expression get expression => _expression;
 
   /**
-   * Return the semicolon terminating the statement.
+   * Return the semicolon terminating the statement, or `null` if the expression is a function
+   * expression and therefore isn't followed by a semicolon.
    *
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   bool get isSynthetic => _expression.isSynthetic && _semicolon.isSynthetic;
 
   /**
    * Set the expression that comprises the statement to the given expression.
    *
    * @param expression the expression that comprises the statement
@@ skipping 245 matching lines @@
    * The token representing the 'this' keyword.
    */
   Token _thisToken;
 
   /**
    * The token representing the period.
    */
   Token _period;
 
   /**
-   * The parameters of the function-typed parameter.
+   * The parameters of the function-typed parameter, or `null` if this is not a function-typed
+   * field formal parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
@@ skipping 30 matching lines @@
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _thisToken;
   }
   Token get endToken => identifier.endToken;
 
   /**
-   * Return the token representing either the 'final', 'const' or 'var' keyword.
+   * Return the token representing either the 'final', 'const' or 'var' keyword, or `null` if
+   * no keyword was used.
    *
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the parameters of the function-typed parameter, or `null` if this is not a
    * function-typed field formal parameter.
    *
    * @return the parameters of the function-typed parameter
@@ skipping 317 matching lines @@
    * validly have neither.
    */
   Expression _initialization;
 
   /**
    * The semicolon separating the initializer and the condition.
    */
   Token _leftSeparator;
 
   /**
-   * The condition used to determine when to terminate the loop.
+   * The condition used to determine when to terminate the loop, or `null` if there is no
+   * condition.
    */
   Expression _condition;
 
   /**
    * The semicolon separating the condition and the updater.
    */
   Token _rightSeparator;
 
   /**
    * The list of expressions run after each execution of the loop body.
@@ skipping 57 matching lines @@
   Token get beginToken => _forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
   /**
-   * Return the condition used to determine when to terminate the loop.
+   * Return the condition used to determine when to terminate the loop, or `null` if there is
+   * no condition.
    *
    * @return the condition used to determine when to terminate the loop
    */
   Expression get condition => _condition;
   Token get endToken => _body.endToken;
 
   /**
    * Return the token representing the 'for' keyword.
    *
    * @return the token representing the 'for' keyword
@@ skipping 233 matching lines @@
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The parameters associated with the method.
    */
   NodeList<FormalParameter> _parameters;
 
   /**
-   * The left square bracket ('[') or left curly brace ('{') introducing the optional parameters.
+   * The left square bracket ('[') or left curly brace ('{') introducing the optional parameters, or
+   * `null` if there are no optional parameters.
    */
   Token _leftDelimiter;
 
   /**
-   * The right square bracket (']') or right curly brace ('}') introducing the optional parameters.
+   * The right square bracket (']') or right curly brace ('}') introducing the optional parameters,
+   * or `null` if there are no optional parameters.
    */
   Token _rightDelimiter;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * Initialize a newly created parameter list.
@@ skipping 18 matching lines @@
    *
    * @param leftParenthesis the left parenthesis
    * @param parameters the parameters associated with the method
    * @param leftDelimiter the left delimiter introducing the optional parameters
    * @param rightDelimiter the right delimiter introducing the optional parameters
    * @param rightParenthesis the right parenthesis
    */
   FormalParameterList({Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis}) : this.full(leftParenthesis, parameters, leftDelimiter, rightDelimiter, rightParenthesis);
   accept(ASTVisitor visitor) => visitor.visitFormalParameterList(this);
   Token get beginToken => _leftParenthesis;
-
-  /**
-   * Return an array containing the elements representing the parameters in this list. The array
-   * will contain `null`s if the parameters in this list have not been resolved.
-   *
-   * @return the elements representing the parameters in this list
-   */
-  List<ParameterElement> get elements {
-    int count = _parameters.length;
-    List<ParameterElement> types = new List<ParameterElement>(count);
-    for (int i = 0; i < count; i++) {
-      types[i] = _parameters[i].element;
-    }
-    return types;
-  }
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left square bracket ('[') or left curly brace ('{') introducing the optional
-   * parameters.
+   * parameters, or `null` if there are no optional parameters.
    *
    * @return the left square bracket ('[') or left curly brace ('{') introducing the optional
    *         parameters
    */
   Token get leftDelimiter => _leftDelimiter;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
+   * Return an array containing the elements representing the parameters in this list. The array
+   * will contain `null`s if the parameters in this list have not been resolved.
+   *
+   * @return the elements representing the parameters in this list
+   */
+  List<ParameterElement> get parameterElements {
+    int count = _parameters.length;
+    List<ParameterElement> types = new List<ParameterElement>(count);
+    for (int i = 0; i < count; i++) {
+      types[i] = _parameters[i].element;
+    }
+    return types;
+  }
+
+  /**
    * Return the parameters associated with the method.
    *
    * @return the parameters associated with the method
    */
   NodeList<FormalParameter> get parameters => _parameters;
 
   /**
    * Return the right square bracket (']') or right curly brace ('}') introducing the optional
-   * parameters.
+   * parameters, or `null` if there are no optional parameters.
    *
    * @return the right square bracket (']') or right curly brace ('}') introducing the optional
    *         parameters
    */
   Token get rightDelimiter => _rightDelimiter;
 
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
@@ skipping 477 matching lines @@
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => _function.beginToken;
 
   /**
-   * Return the element associated with the function being invoked based on propagated type
-   * information, or `null` if the AST structure has not been resolved or the function could
-   * not be resolved. One common example of the latter case is an expression whose value can change
-   * over time.
+   * Return the best element available for the function being invoked. If resolution was able to
+   * find a better element based on type propagation, that element will be returned. Otherwise, the
+   * element found using the result of static analysis will be returned. If resolution has not been
+   * performed, then `null` will be returned.
    *
-   * @return the element associated with the function being invoked
+   * @return the best element available for this function
    */
-  ExecutableElement get element => _propagatedElement;
+  ExecutableElement get bestElement {
+    ExecutableElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the expression producing the function being invoked.
    *
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
 
   /**
+   * Return the element associated with the function being invoked based on propagated type
+   * information, or `null` if the AST structure has not been resolved or the function could
+   * not be resolved. One common example of the latter case is an expression whose value can change
+   * over time.
+   *
+   * @return the element associated with the function being invoked
+   */
+  ExecutableElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the element associated with the function being invoked based on static type information,
    * or `null` if the AST structure has not been resolved or the function could not be
    * resolved. One common example of the latter case is an expression whose value can change over
    * time.
    *
    * @return the element associated with the function
    */
   ExecutableElement get staticElement => _staticElement;
 
   /**
    * Set the list of arguments to the method to the given list.
    *
    * @param argumentList the list of arguments to the method
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
 
   /**
-   * Set the element associated with the function being invoked based on propagated type information
-   * to the given element.
-   *
-   * @param element the element to be associated with the function being invoked
-   */
-  void set element(ExecutableElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the expression producing the function being invoked to the given expression.
    *
    * @param function the expression producing the function being invoked
    */
   void set function(Expression function2) {
     function2 = becomeParentOf(function2);
   }
 
   /**
+   * Set the element associated with the function being invoked based on propagated type information
+   * to the given element.
+   *
+   * @param element the element to be associated with the function being invoked
+   */
+  void set propagatedElement(ExecutableElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the element associated with the function being invoked based on static type information to
    * the given element.
    *
    * @param element the element to be associated with the function
    */
   void set staticElement(ExecutableElement element) {
     this._staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_function, visitor);
@@ skipping 375 matching lines @@
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * The statement that is executed if the condition evaluates to `true`.
    */
   Statement _thenStatement;
 
   /**
-   * The token representing the 'else' keyword.
+   * The token representing the 'else' keyword, or `null` if there is no else statement.
    */
   Token _elseKeyword;
 
   /**
    * The statement that is executed if the condition evaluates to `false`, or `null` if
    * there is no else statement.
    */
   Statement _elseStatement;
 
   /**
@@ skipping 33 matching lines @@
   Token get beginToken => _ifKeyword;
 
   /**
    * Return the condition used to determine which of the statements is executed next.
    *
    * @return the condition used to determine which statement is executed next
    */
   Expression get condition => _condition;
 
   /**
-   * Return the token representing the 'else' keyword.
+   * Return the token representing the 'else' keyword, or `null` if there is no else
+   * statement.
    *
    * @return the token representing the 'else' keyword
    */
   Token get elseKeyword => _elseKeyword;
 
   /**
    * Return the statement that is executed if the condition evaluates to `false`, or
    * `null` if there is no else statement.
    *
    * @return the statement that is executed if the condition evaluates to `false`
@@ skipping 374 matching lines @@
   /**
    * 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 period, Token leftBracket, Expression index, Token rightBracket}) : this.forCascade_full(period, leftBracket, index, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
-
-  /**
-   * Return the expression used to compute the object being indexed, or `null` if this index
-   * expression is part of a cascade expression.
-   *
-   * @return the expression used to compute the object being indexed
-   * @see #getRealTarget()
-   */
-  Expression get array => _target;
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return _period;
   }
 
   /**
-   * Return the element associated with the operator based on the propagated type of the target, or
-   * `null` if the AST structure has not been resolved or if the operator could not be
-   * resolved. One example of the latter case is an operator that is not defined for the type of the
-   * target.
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
    *
-   * @return the element associated with this operator
+   * @return the best element available for this operator
    */
-  MethodElement get element => _propagatedElement;
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _rightBracket;
 
   /**
    * Return the expression used to compute the index.
    *
    * @return the expression used to compute the index
    */
   Expression get index => _index;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
   /**
    * Return the period ("..") before a cascaded index expression, or `null` if this index
    * expression is not part of a cascade expression.
    *
    * @return the period ("..") before a cascaded index expression
    */
   Token get period => _period;
 
   /**
+   * Return the element associated with the operator based on the propagated type of the target, or
+   * `null` if the AST structure has not been resolved or if the operator could not be
+   * resolved. One example of the latter case is an operator that is not defined for the type of the
+   * target.
+   *
+   * @return the element associated with this operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the expression used to compute the object being indexed. If this index expression is not
-   * part of a cascade expression, then this is the same as [getArray]. If this index
+   * part of a cascade expression, then this is the same as [getTarget]. If this index
    * expression is part of a cascade expression, then the target expression stored with the cascade
    * expression is returned.
    *
    * @return the expression used to compute the object being indexed
-   * @see #getArray()
+   * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
@@ skipping 13 matching lines @@
    * Return the element associated with the operator based on the static type of the target, or
    * `null` if the AST structure has not been resolved or if the operator could not be
    * resolved. One example of the latter case is an operator that is not defined for the type of the
    * target.
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
+   * Return the expression used to compute the object being indexed, or `null` if this index
+   * expression is part of a cascade expression.
+   *
+   * @return the expression used to compute the object being indexed
+   * @see #getRealTarget()
+   */
+  Expression get target => _target;
+
+  /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where the operator '[]' will be invoked
    */
   bool inGetterContext() {
     ASTNode parent = this.parent;
@@ skipping 32 matching lines @@
   /**
    * Return `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
    * [CascadeExpression].
    *
    * @return `true` if this expression is cascaded
    */
   bool get 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 based on the propagated type of the target to the
-   * given element.
-   *
-   * @param element the element to be associated with this operator
-   */
-  void set element(MethodElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the expression used to compute the index to the given expression.
    *
    * @param expression the expression used to compute the index
    */
   void set index(Expression expression) {
     _index = becomeParentOf(expression);
   }
 
   /**
    * Set the left square bracket to the given token.
    *
    * @param bracket the left square bracket
    */
   void set leftBracket(Token bracket) {
     _leftBracket = bracket;
   }
 
   /**
    * Set the period ("..") before a cascaded index expression to the given token.
    *
    * @param period the period ("..") before a cascaded index expression
    */
   void set period(Token period2) {
     this._period = period2;
   }
 
   /**
+   * Set the element associated with the operator based on the propagated type of the target to the
+   * given element.
+   *
+   * @param element the element to be associated with this operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the right square bracket to the given token.
    *
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
   /**
    * Set the element associated with the operator based on the static type of the target to the
    * given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
+
+  /**
+   * 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 target(Expression expression) {
+    _target = becomeParentOf(expression);
+  }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the index expression will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getParameterElement].
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the index
    *         expression will be bound
    */
   ParameterElement get propagatedParameterElementForIndex {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
@@ skipping 2003 matching lines @@
   Token get endToken => _name.endToken;
 
   /**
    * Return the token representing the 'native' keyword.
    *
    * @return the token representing the 'native' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * @return the name of the native object that implements the class.
+   * Return the name of the native object that implements the class.
+   *
+   * @return the name of the native object that implements the class
    */
   StringLiteral get name => _name;
 
   /**
    * Set the token representing the 'native' keyword to the given token.
    *
    * @param keyword the token representing the 'native' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
@@ skipping 649 matching lines @@
    * Initialize a newly created postfix expression.
    *
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
   PostfixExpression({Expression operand, Token operator}) : this.full(operand, operator);
   accept(ASTVisitor visitor) => visitor.visitPostfixExpression(this);
   Token get beginToken => _operand.beginToken;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * or if the operator could not be resolved. One example of the latter case is an operator that is
-   * not defined for the type of the operand.
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
    *
-   * @return the element associated with the operator
+   * @return the best element available for this operator
    */
-  MethodElement get element => _propagatedElement;
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _operator;
 
   /**
    * Return the expression computing the operand for the operator.
    *
    * @return the expression computing the operand for the operator
    */
   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;
 
   /**
+   * Return the element associated with the operator based on the propagated type of the operand, or
+   * `null` if the AST structure has not been resolved, if the operator is not user definable,
+   * or if the operator could not be resolved. One example of the latter case is an operator that is
+   * not defined for the type of the operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the element associated with the operator based on the static type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
-   * Set the element associated with the operator based on the propagated type of the operand to the
-   * given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set element(MethodElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the expression computing the operand for the operator to the given expression.
    *
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
 
   /**
    * Set the postfix operator being applied to the operand to the given operator.
    *
    * @param operator the postfix operator being applied to the operand
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
 
   /**
+   * Set the element associated with the operator based on the propagated type of the operand to the
+   * given element.
+   *
+   * @param element the element to be associated with the operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getParameterElement].
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
@@ skipping 74 matching lines @@
    * Initialize a newly created prefix expression.
    *
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
   PrefixExpression({Token operator, Expression operand}) : this.full(operator, operand);
   accept(ASTVisitor visitor) => visitor.visitPrefixExpression(this);
   Token get beginToken => _operator;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * or if the operator could not be resolved. One example of the latter case is an operator that is
-   * not defined for the type of the operand.
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
    *
-   * @return the element associated with the operator
+   * @return the best element available for this operator
    */
-  MethodElement get element => _propagatedElement;
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
   Token get endToken => _operand.endToken;
 
   /**
    * Return the expression computing the operand for the operator.
    *
    * @return the expression computing the operand for the operator
    */
   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;
 
   /**
+   * Return the element associated with the operator based on the propagated type of the operand, or
+   * `null` if the AST structure has not been resolved, if the operator is not user definable,
+   * or if the operator could not be resolved. One example of the latter case is an operator that is
+   * not defined for the type of the operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
    * Return the element associated with the operator based on the static type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
-   * Set the element associated with the operator based on the propagated type of the operand to the
-   * given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set element(MethodElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the expression computing the operand for the operator to the given expression.
    *
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
 
   /**
    * Set the prefix operator being applied to the operand to the given operator.
    *
    * @param operator the prefix operator being applied to the operand
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
 
   /**
+   * Set the element associated with the operator based on the propagated type of the operand to the
+   * given element.
+   *
+   * @param element the element to be associated with the operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getParameterElement].
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
@@ skipping 1932 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
  * symbolLiteral ::=
- *     '#' [SimpleIdentifier] ('.' [SimpleIdentifier])*
+ *     '#' (operator | (identifier ('.' identifier)*))
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class SymbolLiteral extends Literal {
 
   /**
    * The token introducing the literal.
    */
   Token _poundSign;
 
   /**
    * The components of the literal.
    */
-  NodeList<SimpleIdentifier> _components;
+  List<Token> _components;
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
-  SymbolLiteral.full(Token poundSign, List<SimpleIdentifier> components) {
-    this._components = new NodeList<SimpleIdentifier>(this);
+  SymbolLiteral.full(Token poundSign, List<Token> components) {
     this._poundSign = poundSign;
-    this._components.addAll(components);
+    this._components = components;
   }
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
-  SymbolLiteral({Token poundSign, List<SimpleIdentifier> components}) : this.full(poundSign, components);
+  SymbolLiteral({Token poundSign, List<Token> components}) : this.full(poundSign, components);
   accept(ASTVisitor visitor) => visitor.visitSymbolLiteral(this);
   Token get beginToken => _poundSign;
 
   /**
    * Return the components of the literal.
    *
    * @return the components of the literal
    */
-  NodeList<SimpleIdentifier> get components => _components;
-  Token get endToken => _components.endToken;
+  List<Token> get components => _components;
+  Token get endToken => _components[_components.length - 1];
 
   /**
    * Return the token introducing the literal.
    *
    * @return the token introducing the literal
    */
   Token get poundSign => _poundSign;
 
   /**
    * Set the token introducing the literal to the given token.
    *
    * @param poundSign the token introducing the literal
    */
   void set poundSign(Token poundSign2) {
     this._poundSign = poundSign2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
-    _components.accept(visitor);
   }
 }
 /**
  * Instances of the class `ThisExpression` represent a this expression.
  *
  * <pre>
  * thisExpression ::=
  *     'this'
  * </pre>
  *
@@ skipping 729 matching lines @@
   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 'extends' keyword, or `null` if there was no explicit
+   * upper bound.
    *
-   * @return the token representing the 'assert' keyword
+   * @return the token representing the 'extends' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the name of the type parameter.
    *
    * @return the name of the type parameter
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the upper bound for legal arguments to the given type name.
    *
    * @param typeName the name of the upper bound for legal arguments
    */
   void set bound(TypeName typeName) {
     _bound = becomeParentOf(typeName);
   }
 
   /**
-   * Set the token representing the 'assert' keyword to the given token.
+   * Set the token representing the 'extends' keyword to the given token.
    *
-   * @param keyword the token representing the 'assert' keyword
+   * @param keyword the token representing the 'extends' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
    * Set the name of the type parameter to the given identifier.
    *
    * @param identifier the name of the type parameter
    */
@@ skipping 831 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 /**
  * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure, similar to [GeneralizingASTVisitor]. This
  * visitor uses a breadth-first ordering rather than the depth-first ordering of
  * [GeneralizingASTVisitor].
  *
+ * Subclasses that override a visit method must either invoke the overridden visit method or
+ * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
+ * for superclasses of the node to not be invoked and will cause the children of the visited node to
+ * not be visited.
+ *
+ * In addition, subclasses should <b>not</b> explicitly visit the children of a node, but should
+ * ensure that the method [visitNode] is used to visit the children (either directly
+ * or indirectly). Failure to do will break the order in which nodes are visited.
+ *
  * @coverage dart.engine.ast
  */
 class BreadthFirstVisitor<R> extends GeneralizingASTVisitor<R> {
+
+  /**
+   * A queue holding the nodes that have not yet been visited in the order in which they ought to be
+   * visited.
+   */
   Queue<ASTNode> _queue = new Queue<ASTNode>();
+
+  /**
+   * A visitor, used to visit the children of the current node, that will add the nodes it visits to
+   * the [queue].
+   */
   GeneralizingASTVisitor<Object> _childVisitor;
 
   /**
-   * Visit all nodes in the tree starting at the given `root` node, in depth-first order.
+   * Visit all nodes in the tree starting at the given `root` node, in breadth-first order.
    *
-   * @param root the root of the ASTNode tree
+   * @param root the root of the AST structure to be visited
    */
   void visitAllNodes(ASTNode root) {
     _queue.add(root);
     while (!_queue.isEmpty) {
       ASTNode next = _queue.removeFirst();
       next.accept(this);
     }
   }
   R visitNode(ASTNode node) {
     node.visitChildren(_childVisitor);
@@ skipping 278 matching lines @@
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.append(value);
     }
     return builder.toString();
   }
   Object visitSymbolLiteral(SymbolLiteral node) {
     JavaStringBuilder builder = new JavaStringBuilder();
-    for (SimpleIdentifier component in node.components) {
+    for (Token component in node.components) {
       if (builder.length > 0) {
         builder.appendChar(0x2E);
       }
-      builder.append(component.name);
+      builder.append(component.lexeme);
     }
     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
    */
@@ skipping 22 matching lines @@
    */
   static Element locate(ASTNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
 }
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
-  Element visitBinaryExpression(BinaryExpression node) => node.element;
+  Element visitAssignmentExpression(AssignmentExpression node) => node.bestElement;
+  Element visitBinaryExpression(BinaryExpression node) => node.bestElement;
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
   Element visitCompilationUnit(CompilationUnit node) => node.element;
   Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
   Element visitIdentifier(Identifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration decl = parent as ConstructorDeclaration;
       Identifier returnType = decl.returnType;
       if (identical(returnType, node)) {
         SimpleIdentifier name = decl.name;
         if (name != null) {
           return name.element;
         }
         Element element = node.element;
         if (element is ClassElement) {
           return ((element as ClassElement)).unnamedConstructor;
         }
       }
     }
     if (parent is LibraryIdentifier) {
       ASTNode grandParent = ((parent as LibraryIdentifier)).parent;
       if (grandParent is PartOfDirective) {
         Element element = ((grandParent as PartOfDirective)).element;
         if (element is LibraryElement) {
           return ((element as LibraryElement)).definingCompilationUnit;
         }
       }
     }
-    return node.element;
+    Element element = node.element;
+    if (element == null) {
+      element = node.staticElement;
+    }
+    return element;
   }
   Element visitImportDirective(ImportDirective node) => node.element;
-  Element visitIndexExpression(IndexExpression node) => node.element;
+  Element visitIndexExpression(IndexExpression node) => node.bestElement;
   Element visitInstanceCreationExpression(InstanceCreationExpression node) => node.element;
   Element visitLibraryDirective(LibraryDirective node) => node.element;
   Element visitMethodDeclaration(MethodDeclaration node) => node.element;
   Element visitMethodInvocation(MethodInvocation node) => node.methodName.element;
-  Element visitPostfixExpression(PostfixExpression node) => node.element;
+  Element visitPostfixExpression(PostfixExpression node) => node.bestElement;
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.element;
-  Element visitPrefixExpression(PrefixExpression node) => node.element;
+  Element visitPrefixExpression(PrefixExpression node) => node.bestElement;
   Element visitStringLiteral(StringLiteral node) {
     ASTNode parent = node.parent;
     if (parent is UriBasedDirective) {
       return ((parent as UriBasedDirective)).uriElement;
     }
     return null;
   }
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 /**
@@ skipping 1164 matching lines @@
     visit(node.uri);
     visit3(" as ", node.prefix);
     visitList4(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       _writer.print("..");
     } else {
-      visit(node.array);
+      visit(node.target);
     }
     _writer.print('[');
     visit(node.index);
     _writer.print(']');
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     visit5(node.keyword, " ");
     visit(node.constructorName);
     visit(node.argumentList);
@@ skipping 238 matching lines @@
   Object visitSwitchStatement(SwitchStatement node) {
     _writer.print("switch (");
     visit(node.expression);
     _writer.print(") {");
     visitList2(node.members, " ");
     _writer.print("}");
     return null;
   }
   Object visitSymbolLiteral(SymbolLiteral node) {
     _writer.print("#");
-    visitList2(node.components, ".");
+    List<Token> components = node.components;
+    for (int i = 0; i < components.length; i++) {
+      if (i > 0) {
+        _writer.print(".");
+      }
+      _writer.print(components[i].lexeme);
+    }
     return null;
   }
   Object visitThisExpression(ThisExpression node) {
     _writer.print("this");
     return null;
   }
   Object visitThrowExpression(ThrowExpression node) {
     _writer.print("throw ");
     visit(node.expression);
     return null;
@@ skipping 263 matching lines @@
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone2(node.function), clone2(node.argumentList));
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.returnType), clone2(node.name), clone2(node.typeParameters), clone2(node.parameters), node.semicolon);
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.returnType), clone2(node.identifier), clone2(node.parameters));
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone3(node.hiddenNames));
   IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.thenStatement), node.elseKeyword, clone2(node.elseStatement));
   ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(node.keyword, clone3(node.interfaces));
   ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), node.asToken, clone2(node.prefix), clone3(node.combinators), node.semicolon);
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = node.period;
     if (period == null) {
-      return new IndexExpression.forTarget_full(clone2(node.array), node.leftBracket, clone2(node.index), node.rightBracket);
+      return new IndexExpression.forTarget_full(clone2(node.target), node.leftBracket, clone2(node.index), node.rightBracket);
     } else {
       return new IndexExpression.forCascade_full(period, node.leftBracket, clone2(node.index), node.rightBracket);
     }
   }
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression.full(node.keyword, clone2(node.constructorName), clone2(node.argumentList));
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral.full(node.literal, node.value);
   InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(node.leftBracket, clone2(node.expression), node.rightBracket);
   InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(node.contents, node.value);
   IsExpression visitIsExpression(IsExpression node) => new IsExpression.full(clone2(node.expression), node.isOperator, node.notOperator, clone2(node.type));
   Label visitLabel(Label node) => new Label.full(clone2(node.label), node.colon);
@@ skipping 23 matching lines @@
   ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator.full(node.keyword, clone3(node.shownNames));
   SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => new SimpleIdentifier.full(node.token);
   SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => new SimpleStringLiteral.full(node.literal, node.value);
   StringInterpolation visitStringInterpolation(StringInterpolation node) => new StringInterpolation.full(clone3(node.elements));
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation.full(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
   SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression.full(node.keyword);
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase.full(clone3(node.labels), node.keyword, clone2(node.expression), node.colon, clone3(node.statements));
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault.full(clone3(node.labels), node.keyword, node.colon, clone3(node.statements));
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement.full(node.keyword, node.leftParenthesis, clone2(node.expression), node.rightParenthesis, node.leftBracket, clone3(node.members), node.rightBracket);
-  ASTNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral.full(node.poundSign, clone3(node.components));
+  ASTNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral.full(node.poundSign, node.components);
   ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression.full(node.keyword);
   ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression.full(node.keyword, clone2(node.expression));
   TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.variables), node.semicolon);
   TryStatement visitTryStatement(TryStatement node) => new TryStatement.full(node.tryKeyword, clone2(node.body), clone3(node.catchClauses), node.finallyKeyword, clone2(node.finallyClause));
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList.full(node.leftBracket, clone3(node.arguments), node.rightBracket);
   TypeName visitTypeName(TypeName node) => new TypeName.full(clone2(node.name), clone2(node.typeArguments));
   TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.name), node.keyword, clone2(node.bound));
   TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList.full(node.leftBracket, clone3(node.typeParameters), node.rightBracket);
-  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.name), node.equals, clone2(node.initializer));
-  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone3(node.variables));
+  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration.full(null, clone3(node.metadata), clone2(node.name), node.equals, clone2(node.initializer));
+  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList.full(null, clone3(node.metadata), node.keyword, clone2(node.type), clone3(node.variables));
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement.full(clone2(node.variables), node.semicolon);
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement.full(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.body));
   WithClause visitWithClause(WithClause node) => new WithClause.full(node.withKeyword, clone3(node.mixinTypes));
   ASTNode clone2(ASTNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as ASTNode;
   }
   List clone3(NodeList nodes) {
@@ skipping 205 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;
   }
 }