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 2777 matching lines @@
    * The parsing errors encountered when the receiver was parsed.
    */
   List<AnalysisError> _parsingErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The resolution errors encountered when the receiver was resolved.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
+   * The hints reported when the receiver was analyzed.
+   */
+  List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
+
+  /**
    * Initialize a newly created compilation unit to have the given directives and declarations.
    *
    * @param beginToken the first token in the token stream
    * @param scriptTag the script tag at the beginning of the compilation unit
    * @param directives the directives contained in this compilation unit
    * @param declarations the declarations contained in this compilation unit
    * @param endToken the last token in the token stream
    */
   CompilationUnit.full(Token beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, Token endToken) {
     this.directives = new NodeList<Directive>(this);
@@ skipping 21 matching lines @@
 
   /**
    * 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 the errors associated with the receiver
    */
   List<AnalysisError> get errors {
     List<AnalysisError> parserErrors = parsingErrors;
     List<AnalysisError> resolverErrors = resolutionErrors;
-    if (resolverErrors.length == 0) {
+    List<AnalysisError> hints = this.hints;
+    if (resolverErrors.length == 0 && hints.length == 0) {
       return parserErrors;
-    } else if (parserErrors.length == 0) {
+    } else if (parserErrors.length == 0 && hints.length == 0) {
       return resolverErrors;
+    } else if (parserErrors.length == 0 && resolverErrors.length == 0) {
+      return hints;
     } else {
-      List<AnalysisError> allErrors = new List<AnalysisError>(parserErrors.length + resolverErrors.length);
+      List<AnalysisError> allErrors = new List<AnalysisError>(parserErrors.length + resolverErrors.length + hints.length);
       JavaSystem.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
       JavaSystem.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
+      JavaSystem.arraycopy(hints, 0, allErrors, parserErrors.length + resolverErrors.length, hints.length);
       return allErrors;
     }
   }
+
+  /**
+   * Return an array containing all of the hints associated with the receiver. The array will be
+   * empty if the receiver has not been analyzed.
+   *
+   * @return the hints associated with the receiver
+   */
+  List<AnalysisError> get hints => _hints;
   int get length {
     Token endToken = this.endToken;
     if (endToken == null) {
       return 0;
     }
     return endToken.offset + endToken.length;
   }
   int get offset => 0;
 
   /**
@@ skipping 13 matching lines @@
 
   /**
    * 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 reported hints associated with this compilation unit.
+   *
+   * @param the hints to be associated with this compilation unit
+   */
+  void set hints(List<AnalysisError> errors) {
+    _hints = errors == null ? AnalysisError.NO_ERRORS : errors;
+  }
+
+  /**
    * Set the parse errors associated with this compilation unit to the given 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;
   }
 
   /**
    * Set the resolution errors associated with this compilation unit to the given errors.
@@ skipping 660 matching lines @@
   SimpleIdentifier _name;
 
   /**
    * The element associated with this constructor name based on static type information, or
    * `null` if the AST structure has not been resolved or if this constructor name could not
    * be resolved.
    */
   ConstructorElement _staticElement;
 
   /**
-   * The element associated with this constructor name based on propagated type information, or
-   * `null` if the AST structure has not been resolved or if this constructor name could not
-   * be resolved.
-   */
-  ConstructorElement _propagatedElement;
-
-  /**
    * Initialize a newly created constructor name.
    *
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName.full(TypeName type, Token period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
     this.period = period;
     this._name = becomeParentOf(name);
   }
 
   /**
    * Initialize a newly created constructor name.
    *
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName({TypeName type, Token period, SimpleIdentifier name}) : this.full(type, period, name);
   accept(ASTVisitor visitor) => visitor.visitConstructorName(this);
   Token get beginToken => _type.beginToken;
-
-  /**
-   * Return the element associated with this constructor name based on propagated type information,
-   * or `null` if the AST structure has not been resolved or if this constructor name could
-   * not be resolved.
-   *
-   * @return the element associated with this constructor name
-   */
-  ConstructorElement get element => _propagatedElement;
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   /**
    * Return the name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
@@ skipping 12 matching lines @@
   ConstructorElement get staticElement => _staticElement;
 
   /**
    * Return the name of the type defining the constructor.
    *
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
 
   /**
-   * Set the element associated with this constructor name based on propagated type information to
-   * the given element.
-   *
-   * @param element the element to be associated with this constructor name
-   */
-  void set element(ConstructorElement element2) {
-    _propagatedElement = element2;
-  }
-
-  /**
    * Set the name of the constructor to the given name.
    *
    * @param name the name of the constructor
    */
   void set name(SimpleIdentifier name2) {
     this._name = becomeParentOf(name2);
   }
 
   /**
    * Set the element associated with this constructor name based on static type information to the
@@ skipping 759 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 parameter element information available for this expression. If type
+   * propagation was able to find a better parameter element than static analysis, that type will be
+   * returned. Otherwise, the result of static analysis will be returned.
+   *
+   * @return the parameter element representing the parameter to which the value of this expression
+   *         will be bound
+   */
+  ParameterElement get bestParameterElement {
+    ParameterElement propagatedElement = propagatedParameterElement;
+    if (propagatedElement != null) {
+      return propagatedElement;
+    }
+    return staticParameterElement;
+  }
+
+  /**
    * 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;
@@ skipping 515 matching lines @@
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class `ForEachStatement` represent a for-each statement.
  *
  * <pre>
  * forEachStatement ::=
- *     'for' '(' [SimpleFormalParameter] 'in' [Expression] ')' [Block]
+ *     'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
+ *   | 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class ForEachStatement extends Statement {
 
   /**
    * The token representing the 'for' keyword.
    */
   Token forKeyword;
 
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
-   * The declaration of the loop variable.
+   * The declaration of the loop variable, or `null` if the loop variable is a simple
+   * identifier.
    */
   DeclaredIdentifier _loopVariable;
 
   /**
+   * The loop variable, or `null` if the loop variable is declared in the 'for'.
+   */
+  SimpleIdentifier _identifier;
+
+  /**
    * The token representing the 'in' keyword.
    */
   Token inKeyword;
 
   /**
    * The expression evaluated to produce the iterator.
    */
   Expression _iterator;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created for-each statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopVariable the declaration of the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement.full(Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+  ForEachStatement.con1_full(Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
     this.forKeyword = forKeyword;
     this.leftParenthesis = leftParenthesis;
     this._loopVariable = becomeParentOf(loopVariable);
     this.inKeyword = inKeyword;
     this._iterator = becomeParentOf(iterator);
     this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopVariable the declaration of the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement({Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.full(forKeyword, leftParenthesis, loopVariable, inKeyword, iterator, rightParenthesis, body);
+  ForEachStatement.con1({Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.con1_full(forKeyword, leftParenthesis, loopVariable, inKeyword, iterator, rightParenthesis, body);
+
+  /**
+   * Initialize a newly created for-each statement.
+   *
+   * @param forKeyword the token representing the 'for' keyword
+   * @param leftParenthesis the left parenthesis
+   * @param identifier the loop variable
+   * @param iterator the expression evaluated to produce the iterator
+   * @param rightParenthesis the right parenthesis
+   * @param body the body of the loop
+   */
+  ForEachStatement.con2_full(Token forKeyword, Token leftParenthesis, SimpleIdentifier identifier, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+    this.forKeyword = forKeyword;
+    this.leftParenthesis = leftParenthesis;
+    this._identifier = becomeParentOf(identifier);
+    this.inKeyword = inKeyword;
+    this._iterator = becomeParentOf(iterator);
+    this.rightParenthesis = rightParenthesis;
+    this._body = becomeParentOf(body);
+  }
+
+  /**
+   * Initialize a newly created for-each statement.
+   *
+   * @param forKeyword the token representing the 'for' keyword
+   * @param leftParenthesis the left parenthesis
+   * @param identifier the loop variable
+   * @param iterator the expression evaluated to produce the iterator
+   * @param rightParenthesis the right parenthesis
+   * @param body the body of the loop
+   */
+  ForEachStatement.con2({Token forKeyword, Token leftParenthesis, SimpleIdentifier identifier, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.con2_full(forKeyword, leftParenthesis, identifier, inKeyword, iterator, rightParenthesis, body);
   accept(ASTVisitor visitor) => visitor.visitForEachStatement(this);
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
   Token get endToken => _body.endToken;
 
   /**
+   * Return the loop variable, or `null` if the loop variable is declared in the 'for'.
+   *
+   * @return the loop variable
+   */
+  SimpleIdentifier get identifier => _identifier;
+
+  /**
    * Return the expression evaluated to produce the iterator.
    *
    * @return the expression evaluated to produce the iterator
    */
   Expression get iterator => _iterator;
 
   /**
-   * Return the declaration of the loop variable.
+   * Return the declaration of the loop variable, or `null` if the loop variable is a simple
+   * identifier.
    *
    * @return the declaration of the loop variable
    */
   DeclaredIdentifier get loopVariable => _loopVariable;
 
   /**
    * Set the body of the loop to the given block.
    *
    * @param body the body of the loop
    */
   void set body(Statement body2) {
     this._body = becomeParentOf(body2);
   }
 
   /**
+   * Set the loop variable to the given variable.
+   *
+   * @param identifier the loop variable
+   */
+  void set identifier(SimpleIdentifier identifier2) {
+    this._identifier = becomeParentOf(identifier2);
+  }
+
+  /**
    * Set the expression evaluated to produce the iterator to the given expression.
    *
    * @param expression the expression evaluated to produce the iterator
    */
   void set iterator(Expression expression) {
     _iterator = becomeParentOf(expression);
   }
 
   /**
    * Set the declaration of the loop variable to the given variable.
    *
    * @param variable the declaration of the loop variable
    */
   void set loopVariable(DeclaredIdentifier variable) {
     _loopVariable = becomeParentOf(variable);
   }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_loopVariable, visitor);
+    safelyVisitChild(_identifier, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class `ForStatement` represent a for statement.
  *
  * <pre>
  * forStatement ::=
  *     'for' '(' forLoopParts ')' [Statement]
@@ skipping 1420 matching lines @@
  * Instances of the class `ImportDirective` represent an import directive.
  *
  * <pre>
  * importDirective ::=
  *     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class ImportDirective extends NamespaceDirective {
+  static Comparator<ImportDirective> COMPARATOR = (ImportDirective import1, ImportDirective import2) {
+    StringLiteral uri1 = import1.uri;
+    StringLiteral uri2 = import2.uri;
+    String uriStr1 = uri1.stringValue;
+    String uriStr2 = uri2.stringValue;
+    if (uriStr1 != null || uriStr2 != null) {
+      if (uriStr1 == null) {
+        return -1;
+      } else if (uriStr2 == null) {
+        return 1;
+      } else {
+        int compare = uriStr1.compareTo(uriStr2);
+        if (compare != 0) {
+          return compare;
+        }
+      }
+    }
+    SimpleIdentifier prefix1 = import1.prefix;
+    SimpleIdentifier prefix2 = import2.prefix;
+    String prefixStr1 = prefix1 != null ? prefix1.name : null;
+    String prefixStr2 = prefix2 != null ? prefix2.name : null;
+    if (prefixStr1 != null || prefixStr2 != null) {
+      if (prefixStr1 == null) {
+        return -1;
+      } else if (prefixStr2 == null) {
+        return 1;
+      } else {
+        int compare = prefixStr1.compareTo(prefixStr2);
+        if (compare != 0) {
+          return compare;
+        }
+      }
+    }
+    NodeList<Combinator> combinators1 = import1.combinators;
+    List<String> allHides1 = new List<String>();
+    List<String> allShows1 = new List<String>();
+    for (Combinator combinator in combinators1) {
+      if (combinator is HideCombinator) {
+        NodeList<SimpleIdentifier> hides = ((combinator as HideCombinator)).hiddenNames;
+        for (SimpleIdentifier simpleIdentifier in hides) {
+          allHides1.add(simpleIdentifier.name);
+        }
+      } else {
+        NodeList<SimpleIdentifier> shows = ((combinator as ShowCombinator)).shownNames;
+        for (SimpleIdentifier simpleIdentifier in shows) {
+          allShows1.add(simpleIdentifier.name);
+        }
+      }
+    }
+    NodeList<Combinator> combinators2 = import2.combinators;
+    List<String> allHides2 = new List<String>();
+    List<String> allShows2 = new List<String>();
+    for (Combinator combinator in combinators2) {
+      if (combinator is HideCombinator) {
+        NodeList<SimpleIdentifier> hides = ((combinator as HideCombinator)).hiddenNames;
+        for (SimpleIdentifier simpleIdentifier in hides) {
+          allHides2.add(simpleIdentifier.name);
+        }
+      } else {
+        NodeList<SimpleIdentifier> shows = ((combinator as ShowCombinator)).shownNames;
+        for (SimpleIdentifier simpleIdentifier in shows) {
+          allShows2.add(simpleIdentifier.name);
+        }
+      }
+    }
+    if (allHides1.length != allHides2.length) {
+      return allHides1.length - allHides2.length;
+    }
+    if (allShows1.length != allShows2.length) {
+      return allShows1.length - allShows2.length;
+    }
+    if (!javaCollectionContainsAll(allHides1, allHides2)) {
+      return -1;
+    }
+    if (!javaCollectionContainsAll(allShows1, allShows2)) {
+      return -1;
+    }
+    return 0;
+  };
 
   /**
    * The token representing the 'as' token, or `null` if the imported names are not prefixed.
    */
   Token asToken;
 
   /**
    * The prefix to be used with the imported names, or `null` if the imported names are not
    * prefixed.
    */
@@ skipping 449 matching lines @@
    */
   ArgumentList _argumentList;
 
   /**
    * The element associated with the constructor based on static type information, or `null`
    * if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or
-   * `null` if the AST structure has not been resolved or if the constructor could not be
-   * resolved.
-   */
-  ConstructorElement element;
-
-  /**
    * Initialize a newly created instance creation expression.
    *
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
   InstanceCreationExpression.full(Token keyword, ConstructorName constructorName, ArgumentList argumentList) {
     this.keyword = keyword;
     this.constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
@@ skipping 2653 matching lines @@
    */
   ArgumentList _argumentList;
 
   /**
    * The element associated with the constructor based on static type information, or `null`
    * if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or
-   * `null` if the AST structure has not been resolved or if the constructor could not be
-   * resolved.
-   */
-  ConstructorElement _propagatedElement;
-
-  /**
    * Initialize a newly created redirecting invocation to invoke the constructor with the given name
    * with the given arguments.
    *
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   RedirectingConstructorInvocation.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this.keyword = keyword;
@@ skipping 22 matching lines @@
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => keyword;
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    *
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
-
-  /**
-   * Return the element associated with the constructor based on propagated type information, or
-   * `null` if the AST structure has not been resolved or if the constructor could not be
-   * resolved.
-   *
-   * @return the element associated with the super constructor
-   */
-  ConstructorElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
-
-  /**
-   * Set the element associated with the constructor based on propagated type information to the
-   * given element.
-   *
-   * @param element the element to be associated with the constructor
-   */
-  void set element(ConstructorElement element2) {
-    _propagatedElement = element2;
-  }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `RethrowExpression` represent a rethrow expression.
  *
  * <pre>
  * rethrowExpression ::=
@@ skipping 506 matching lines @@
       return validateElement(parent, LocalVariableElement, element);
     } else if (parent is FormalParameter && identical(((parent as FormalParameter)).identifier, this)) {
       return validateElement(parent, ParameterElement, element);
     } else if (parent is FunctionDeclaration && identical(((parent as FunctionDeclaration)).name, this)) {
       return validateElement(parent, ExecutableElement, element);
     } else if (parent is FunctionTypeAlias && identical(((parent as FunctionTypeAlias)).name, this)) {
       return validateElement(parent, FunctionTypeAliasElement, element);
     } else if (parent is MethodDeclaration && identical(((parent as MethodDeclaration)).name, this)) {
       return validateElement(parent, ExecutableElement, element);
     } else if (parent is TypeParameter && identical(((parent as TypeParameter)).name, this)) {
-      return validateElement(parent, TypeVariableElement, element);
+      return validateElement(parent, TypeParameterElement, element);
     } else if (parent is VariableDeclaration && identical(((parent as VariableDeclaration)).name, this)) {
       return validateElement(parent, VariableElement, element);
     }
     return element;
   }
 }
 /**
  * Instances of the class `SimpleStringLiteral` represent a string literal expression that
  * does not contain any interpolations.
  *
@@ skipping 239 matching lines @@
    */
   ArgumentList _argumentList;
 
   /**
    * The element associated with the constructor based on static type information, or `null`
    * if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or `null` if the AST structure has not been
-   * resolved or if the constructor could not be resolved.
-   */
-  ConstructorElement _propagatedElement;
-
-  /**
    * Initialize a newly created super invocation to invoke the inherited constructor with the given
    * name with the given arguments.
    *
    * @param keyword the token for the 'super' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   SuperConstructorInvocation.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this.keyword = keyword;
@@ skipping 22 matching lines @@
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => keyword;
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    *
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
-
-  /**
-   * Return the element associated with the constructor based on propagated type information, or
-   * `null` if the AST structure has not been resolved or if the constructor could not be
-   * resolved.
-   *
-   * @return the element associated with the super constructor
-   */
-  ConstructorElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
-
-  /**
-   * Set the element associated with the constructor based on propagated type information to the
-   * given element.
-   *
-   * @param element the element to be associated with the constructor
-   */
-  void set element(ConstructorElement element2) {
-    _propagatedElement = element2;
-  }
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `SuperExpression` represent a super expression.
  *
  * <pre>
  * superExpression ::=
@@ skipping 911 matching lines @@
   TypeParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound}) : this.full(comment, metadata, name, keyword, bound);
   accept(ASTVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    *
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
-  TypeVariableElement get element => _name != null ? (_name.staticElement as TypeVariableElement) : null;
+  TypeParameterElement get element => _name != null ? (_name.staticElement as TypeParameterElement) : null;
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
 
   /**
    * Return the name of the type parameter.
    *
@@ skipping 717 matching lines @@
     while (!_queue.isEmpty) {
       ASTNode next = _queue.removeFirst();
       next.accept(this);
     }
   }
   R visitNode(ASTNode node) {
     node.visitChildren(_childVisitor);
     return null;
   }
   BreadthFirstVisitor() {
-    this._childVisitor = new GeneralizingASTVisitor_1(this);
+    this._childVisitor = new GeneralizingASTVisitor_2(this);
   }
 }
-class GeneralizingASTVisitor_1 extends GeneralizingASTVisitor<Object> {
+class GeneralizingASTVisitor_2 extends GeneralizingASTVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
-  GeneralizingASTVisitor_1(this.BreadthFirstVisitor_this) : super();
+  GeneralizingASTVisitor_2(this.BreadthFirstVisitor_this) : super();
   Object visitNode(ASTNode node) {
     BreadthFirstVisitor_this._queue.add(node);
     return null;
   }
 }
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
  * * A reference to a static constant variable.
- * * An identifier expression that denotes a constant variable, a class or a type variable.
+ * * An identifier expression that denotes a constant variable, a class or a type parameter.
  * * A constant constructor invocation.
  * * A constant list literal.
  * * A constant map literal.
  * * A simple or qualified identifier denoting a top-level function or a static method.
  * * A parenthesized expression `(e)` where `e` is a constant expression.
  * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,
  * `e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
  * numeric, string or boolean value or to `null`.
  * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where
  * `e`, `e1` and `e2` are constant expressions that evaluate to a boolean value or
@@ skipping 1392 matching lines @@
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     visit5(node.keyword, " ");
     visit2(node.type, " ");
     _writer.print("this.");
     visit(node.identifier);
     visit(node.parameters);
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
+    DeclaredIdentifier loopVariable = node.loopVariable;
     _writer.print("for (");
-    visit(node.loopVariable);
+    if (loopVariable == null) {
+      visit(node.identifier);
+    } else {
+      visit(loopVariable);
+    }
     _writer.print(" in ");
     visit(node.iterator);
     _writer.print(") ");
     visit(node.body);
     return null;
   }
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
     NodeList<FormalParameter> parameters = node.parameters;
@@ skipping 611 matching lines @@
       return Comment.createBlockComment(node.tokens);
     }
     return Comment.createEndOfLineComment(node.tokens);
   }
   CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(node.newKeyword, clone2(node.identifier));
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
     CompilationUnit clone = new CompilationUnit.full(node.beginToken, clone2(node.scriptTag), clone3(node.directives), clone3(node.declarations), node.endToken);
     clone.lineInfo = node.lineInfo;
     clone.parsingErrors = node.parsingErrors;
     clone.resolutionErrors = node.resolutionErrors;
+    clone.hints = node.hints;
     return clone;
   }
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression.full(clone2(node.condition), node.question, clone2(node.thenExpression), node.colon, clone2(node.elseExpression));
   ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, clone2(node.returnType), node.period, clone2(node.name), clone2(node.parameters), node.separator, clone3(node.initializers), clone2(node.redirectedConstructor), clone2(node.body));
   ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer.full(node.keyword, node.period, clone2(node.fieldName), node.equals, clone2(node.expression));
   ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName.full(clone2(node.type), node.period, clone2(node.name));
   ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement.full(node.keyword, clone2(node.label), node.semicolon);
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
   DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter.full(clone2(node.parameter), node.kind, node.separator, clone2(node.defaultValue));
   DoStatement visitDoStatement(DoStatement node) => new DoStatement.full(node.doKeyword, clone2(node.body), node.whileKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral.full(node.literal, node.value);
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody.full(node.semicolon);
   EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement.full(node.semicolon);
   ExportDirective visitExportDirective(ExportDirective node) => new ExportDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), clone3(node.combinators), node.semicolon);
   ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody.full(node.functionDefinition, clone2(node.expression), node.semicolon);
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement.full(clone2(node.expression), node.semicolon);
   ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause.full(node.keyword, clone2(node.superclass));
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.staticKeyword, clone2(node.fields), node.semicolon);
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), node.thisToken, node.period, clone2(node.identifier), clone2(node.parameters));
-  ForEachStatement visitForEachStatement(ForEachStatement node) => new ForEachStatement.full(node.forKeyword, node.leftParenthesis, clone2(node.loopVariable), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
+  ForEachStatement visitForEachStatement(ForEachStatement node) {
+    DeclaredIdentifier loopVariable = node.loopVariable;
+    if (loopVariable == null) {
+      return new ForEachStatement.con2_full(node.forKeyword, node.leftParenthesis, clone2(node.identifier), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
+    }
+    return new ForEachStatement.con1_full(node.forKeyword, node.leftParenthesis, clone2(loopVariable), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
+  }
   FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList.full(node.leftParenthesis, clone3(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
   ForStatement visitForStatement(ForStatement node) => new ForStatement.full(node.forKeyword, node.leftParenthesis, clone2(node.variables), clone2(node.initialization), node.leftSeparator, clone2(node.condition), node.rightSeparator, clone3(node.updaters), node.rightParenthesis, clone2(node.body));
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, clone2(node.returnType), node.propertyKeyword, clone2(node.name), clone2(node.functionExpression));
   FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone2(node.functionDeclaration));
   FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression.full(clone2(node.parameters), clone2(node.body));
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone2(node.function), clone2(node.argumentList));
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.returnType), clone2(node.name), clone2(node.typeParameters), clone2(node.parameters), node.semicolon);
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.returnType), clone2(node.identifier), clone2(node.parameters));
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone3(node.hiddenNames));
   IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.thenStatement), node.elseKeyword, clone2(node.elseStatement));
@@ skipping 107 matching lines @@
       addParameters(node.parameters.parameters);
     }
     declaration = node;
     return null;
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
     declaration = node;
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
-    addToScope(node.loopVariable.identifier);
+    DeclaredIdentifier loopVariable = node.loopVariable;
+    if (loopVariable != null) {
+      addToScope(loopVariable.identifier);
+    }
     return super.visitForEachStatement(node);
   }
   Object visitForStatement(ForStatement node) {
     if (_immediateChild != node.variables && node.variables != null) {
       addVariables(node.variables.variables);
     }
     return super.visitForStatement(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     if (node.parent is! FunctionDeclarationStatement) {
       declaration = node;
       return null;
     }
     return super.visitFunctionDeclaration(node);
   }
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _referenceIsWithinLocalFunction = true;
     return super.visitFunctionDeclarationStatement(node);
   }
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parameters != null && _immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
     return super.visitFunctionExpression(node);
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
+    declaration = node;
     if (node.parameters == null) {
       return null;
     }
     if (_immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
-    declaration = node;
     return null;
   }
   Object visitNode(ASTNode node) {
     _immediateChild = node;
     ASTNode parent = node.parent;
     if (parent != null) {
       parent.accept(this);
     }
     return null;
   }
@@ skipping 112 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;
   }
 }