New analyzer snapshot.

pkg/analyzer/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 'source.dart' show LineInfo;
 import 'scanner.dart';
@@ skipping 877 matching lines @@
 
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier representing the argument being tested.
    *
    * @return the identifier representing the argument being tested
    */
   SimpleIdentifier get identifier => _identifier;
 
+  int get precedence => 15;
+
   /**
    * 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 identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 248 matching lines @@
 
   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
    */
   Expression get expression => _expression;
 
+  int get precedence => 7;
+
   /**
    * Return the name of the type being cast to.
    *
    * @return the name of the type being cast to
    */
   TypeName get type => _type;
 
   /**
    * Set the expression used to compute the value being cast to the given expression.
    *
@@ skipping 193 matching lines @@
 
   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;
 
+  int get precedence => 1;
+
   /**
    * 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;
 
@@ skipping 184 matching lines @@
 
   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;
 
+  int get precedence => operator.type.precedence;
+
   /**
    * 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;
 
@@ skipping 397 matching lines @@
    * @param cascadeSections the cascade sections sharing the common target
    */
   CascadeExpression({Expression target, List<Expression> cascadeSections}) : this.full(target, cascadeSections);
 
   accept(ASTVisitor visitor) => visitor.visitCascadeExpression(this);
 
   Token get beginToken => _target.beginToken;
 
   Token get endToken => cascadeSections.endToken;
 
+  int get precedence => 2;
+
   /**
    * Return the target of the cascade sections.
    *
    * @return the target of the cascade sections
    */
   Expression get target => _target;
 
   /**
    * Set the target of the cascade sections to the given expression.
    *
@@ skipping 1181 matching lines @@
 
   /**
    * Return the expression that is executed if the condition evaluates to `false`.
    *
    * @return the expression that is executed if the condition evaluates to `false`
    */
   Expression get elseExpression => _elseExpression;
 
   Token get endToken => _elseExpression.endToken;
 
+  int get precedence => 3;
+
   /**
    * Return the expression that is executed if the condition evaluates to `true`.
    *
    * @return the expression that is executed if the condition evaluates to `true`
    */
   Expression get thenExpression => _thenExpression;
 
   /**
    * Set the condition used to determine which of the expressions is executed next to the given
    * expression.
@@ skipping 1293 matching lines @@
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  *
  * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
-  EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
+  EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new StringToken(TokenType.IDENTIFIER, "", location)) {
     parent.becomeParentOf(this);
   }
 
   EphemeralIdentifier({ASTNode parent, int location}) : this.full(parent, location);
 }
 
 /**
  * Instances of the class `ExportDirective` represent an export directive.
  *
  * <pre>
@@ skipping 96 matching lines @@
   Type2 get bestType {
     if (propagatedType != null) {
       return propagatedType;
     } else if (staticType != null) {
       return staticType;
     }
     return DynamicTypeImpl.instance;
   }
 
   /**
+   * Return the precedence of this expression. The precedence is a positive integer value that
+   * defines how the source code is parsed into an AST. For example `a * b + c` is parsed as
+   * `(a * b) + c` because the precedence of `*` is greater than the precedence of
+   * `+`.
+   *
+   * You should not assume that returned values will stay the same, they might change as result of
+   * specification change. Only relative order should be used.
+   *
+   * @return the precedence of this expression
+   */
+  int get precedence;
+
+  /**
    * 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 propagatedParameterElement {
@@ skipping 1462 matching lines @@
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
    * Return the parameters associated with the function.
    *
    * @return the parameters associated with the function
    */
   FormalParameterList get parameters => _parameters;
 
+  int get precedence => 16;
+
   /**
    * Set the body of the function to the given function body.
    *
    * @param functionBody the body of the function
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
@@ skipping 96 matching lines @@
 
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the expression producing the function being invoked.
    *
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
 
+  int get precedence => 15;
+
   /**
    * 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;
 
@@ skipping 907 matching lines @@
    */
   Expression get index => _index;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
+  int get precedence => 15;
+
   /**
    * 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;
 
@@ skipping 264 matching lines @@
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
 
   Token get endToken => _argumentList.endToken;
 
+  int get precedence => 15;
+
   /**
    * Return `true` if this creation expression is used to invoke a constant constructor.
    *
    * @return `true` if this creation expression is used to invoke a constant constructor
    */
   bool get isConst => keyword is KeywordToken && identical((keyword as KeywordToken).keyword, Keyword.CONST);
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
@@ skipping 311 matching lines @@
 
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    *
    * @return the expression used to compute the value whose type is being tested
    */
   Expression get expression => _expression;
 
+  int get precedence => 7;
+
   /**
    * Return the name of the type being tested for.
    *
    * @return the name of the type being tested for
    */
   TypeName get type => _type;
 
   /**
    * Set the expression used to compute the value whose type is being tested to the given
    * expression.
@@ skipping 291 matching lines @@
       if (needsPeriod) {
         builder.append(".");
       } else {
         needsPeriod = true;
       }
       builder.append(identifier.name);
     }
     return builder.toString();
   }
 
+  int get precedence => 15;
+
   Element get propagatedElement => null;
 
   Element get staticElement => null;
 
   void visitChildren(ASTVisitor visitor) {
     components.accept(visitor);
   }
 }
 
 /**
@@ skipping 116 matching lines @@
  *   | [IntegerLiteral]
  *   | [ListLiteral]
  *   | [MapLiteral]
  *   | [NullLiteral]
  *   | [StringLiteral]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 abstract class Literal extends Expression {
+  int get precedence => 16;
 }
 
 /**
  * Instances of the class `MapLiteral` represent a literal map.
  *
  * <pre>
  * mapLiteral ::=
  *     'const'? ('<' [TypeName] (',' [TypeName])* '>')? '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  * </pre>
  *
@@ skipping 516 matching lines @@
 
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the name of the method being invoked.
    *
    * @return the name of the method being invoked
    */
   SimpleIdentifier get methodName => _methodName;
 
+  int get precedence => 15;
+
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
@@ skipping 132 matching lines @@
    */
   Expression get expression => _expression;
 
   /**
    * Return the name associated with the expression.
    *
    * @return the name associated with the expression
    */
   Label get name => _name;
 
+  int get precedence => 0;
+
   /**
    * Set the expression with which the name is associated to the given expression.
    *
    * @param expression the expression with which the name is associated
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   /**
@@ skipping 433 matching lines @@
    */
   Expression get expression => _expression;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
+  int get precedence => 15;
+
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
    * Set the expression within the parentheses to the given expression.
    *
@@ skipping 249 matching lines @@
 
   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;
 
+  int get precedence => 15;
+
   /**
    * 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;
 
@@ skipping 159 matching lines @@
 
   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;
 
+  int get precedence => 14;
+
   /**
    * 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;
 
@@ skipping 148 matching lines @@
 
   /**
    * Return the identifier being prefixed.
    *
    * @return the identifier being prefixed
    */
   SimpleIdentifier get identifier => _identifier;
 
   String get name => "${_prefix.name}.${_identifier.name}";
 
+  int get precedence => 15;
+
   /**
    * 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;
 
   Element get propagatedElement {
     if (_identifier == null) {
       return null;
@@ skipping 89 matching lines @@
 
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
   Token get endToken => _propertyName.endToken;
 
+  int get precedence => 15;
+
   /**
    * Return the name of the property being accessed.
    *
    * @return the name of the property being accessed
    */
   SimpleIdentifier get propertyName => _propertyName;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
@@ skipping 205 matching lines @@
    * @param keyword the token representing the 'rethrow' keyword
    */
   RethrowExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitRethrowExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
+  int get precedence => 0;
+
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ReturnStatement` represent a return statement.
  *
  * <pre>
  * returnStatement ::=
  *     'return' [Expression]? ';'
@@ skipping 309 matching lines @@
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
   }
 
   Token get endToken => token;
 
   String get name => token.lexeme;
 
+  int get precedence => 16;
+
   Element get propagatedElement => _propagatedElement;
 
   Element get staticElement => _staticElement;
 
   /**
    * Return `true` if this identifier is the name being declared in a declaration.
    *
    * @return `true` if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
@@ skipping 544 matching lines @@
    * @param keyword the token representing the keyword
    */
   SuperExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitSuperExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
+  int get precedence => 16;
+
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `SwitchCase` represent the case in a switch statement.
  *
  * <pre>
  * switchCase ::=
  *     [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
@@ skipping 361 matching lines @@
    * @param keyword the token representing the keyword
    */
   ThisExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitThisExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
+  int get precedence => 16;
+
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ThrowExpression` represent a throw expression.
  *
  * <pre>
  * throwExpression ::=
  *     'throw' [Expression]
@@ skipping 42 matching lines @@
     return keyword;
   }
 
   /**
    * Return the expression computing the exception to be thrown.
    *
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
 
+  int get precedence => 0;
+
   /**
    * Set the expression computing the exception to be thrown to the given expression.
    *
    * @param expression the expression computing the exception to be thrown
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 4226 matching lines @@
   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) {
+    int count = nodes.length;
     List clonedNodes = new List();
-    for (ASTNode node in nodes) {
-      clonedNodes.add(node.accept(this) as ASTNode);
+    for (int i = 0; i < count; i++) {
+      clonedNodes.add((nodes[i]).accept(this) as ASTNode);
     }
     return clonedNodes;
   }
 }
 
 /**
  * Instances of the class `ASTComparator` compare the structure of two ASTNodes to see whether
  * they are equal.
  */
 class ASTComparator implements ASTVisitor<bool> {
   /**
    * Return `true` if the two AST nodes are equal.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the two AST nodes are equal
    */
-  static bool equals3(CompilationUnit first, CompilationUnit second) {
+  static bool equals4(CompilationUnit first, CompilationUnit second) {
     ASTComparator comparator = new ASTComparator();
     return comparator.isEqual(first, second);
   }
 
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqual] is invoked).
    */
   ASTNode _other;
 
@@ skipping 247 matching lines @@
     return isEqual(node.target, other.target) && isEqual6(node.leftBracket, other.leftBracket) && isEqual(node.index, other.index) && isEqual6(node.rightBracket, other.rightBracket);
   }
 
   bool visitInstanceCreationExpression(InstanceCreationExpression node) {
     InstanceCreationExpression other = this._other as InstanceCreationExpression;
     return isEqual6(node.keyword, other.keyword) && isEqual(node.constructorName, other.constructorName) && isEqual(node.argumentList, other.argumentList);
   }
 
   bool visitIntegerLiteral(IntegerLiteral node) {
     IntegerLiteral other = this._other as IntegerLiteral;
-    return isEqual6(node.literal, other.literal) && identical(node.value, other.value);
+    return isEqual6(node.literal, other.literal) && (node.value == other.value);
   }
 
   bool visitInterpolationExpression(InterpolationExpression node) {
     InterpolationExpression other = this._other as InterpolationExpression;
     return isEqual6(node.leftBracket, other.leftBracket) && isEqual(node.expression, other.expression) && isEqual6(node.rightBracket, other.rightBracket);
   }
 
   bool visitInterpolationString(InterpolationString node) {
     InterpolationString other = this._other as InterpolationString;
     return isEqual6(node.contents, other.contents) && node.value == other.value;
@@ skipping 134 matching lines @@
     return isEqual(node.documentationComment, other.documentationComment) && isEqual5(node.metadata, other.metadata) && isEqual6(node.keyword, other.keyword) && isEqual(node.type, other.type) && isEqual(node.identifier, other.identifier);
   }
 
   bool visitSimpleIdentifier(SimpleIdentifier node) {
     SimpleIdentifier other = this._other as SimpleIdentifier;
     return isEqual6(node.token, other.token);
   }
 
   bool visitSimpleStringLiteral(SimpleStringLiteral node) {
     SimpleStringLiteral other = this._other as SimpleStringLiteral;
-    return isEqual6(node.literal, other.literal) && identical(node.value, other.value);
+    return isEqual6(node.literal, other.literal) && (node.value == other.value);
   }
 
   bool visitStringInterpolation(StringInterpolation node) {
     StringInterpolation other = this._other as StringInterpolation;
     return isEqual5(node.elements, other.elements);
   }
 
   bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation other = this._other as SuperConstructorInvocation;
     return isEqual6(node.keyword, other.keyword) && isEqual6(node.period, other.period) && isEqual(node.constructorName, other.constructorName) && isEqual(node.argumentList, other.argumentList);
@@ skipping 987 matching lines @@
   void operator[]=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     _elements[index] as E;
     owner.becomeParentOf(node);
     _elements[index] = node;
   }
   int get length => _elements.length;
 }