Push new analyzer-experimental with Resolver and ResolverTest.

pkg/analyzer-experimental/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'package:analyzer-experimental/src/generated/utilities_dart.dart';
 
 /**
  * Instances of the class {@code CommentAndMetadata} implement a simple data-holder for a method
  * that needs to return multiple values.
+ * @coverage dart.engine.parser
  */
 class CommentAndMetadata {
   /**
    * The documentation comment that was parsed, or {@code null} if none was given.
    */
   Comment _comment;
   /**
    * The metadata that was parsed.
    */
   List<Annotation> _metadata;
@@ skipping 13 matching lines @@
   Comment get comment => _comment;
   /**
    * Return the metadata that was parsed. If there was no metadata, then the list will be empty.
    * @return the metadata that was parsed
    */
   List<Annotation> get metadata => _metadata;
 }
 /**
  * Instances of the class {@code FinalConstVarOrType} implement a simple data-holder for a method
  * that needs to return multiple values.
+ * @coverage dart.engine.parser
  */
 class FinalConstVarOrType {
   /**
    * The 'final', 'const' or 'var' keyword, or {@code null} if none was given.
    */
   Token _keyword;
   /**
    * The type, of {@code null} if no type was specified.
    */
   TypeName _type;
@@ skipping 13 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the type, of {@code null} if no type was specified.
    * @return the type
    */
   TypeName get type => _type;
 }
 /**
  * Instances of the class {@code Modifiers} implement a simple data-holder for a method that needs
  * to return multiple values.
+ * @coverage dart.engine.parser
  */
 class Modifiers {
   /**
    * The token representing the keyword 'abstract', or {@code null} if the keyword was not found.
    */
   Token _abstractKeyword;
   /**
    * The token representing the keyword 'const', or {@code null} if the keyword was not found.
    */
   Token _constKeyword;
@@ skipping 137 matching lines @@
         builder.appendChar(0x20);
       }
       builder.append(keyword.lexeme);
       return true;
     }
     return needsSpace;
   }
 }
 /**
  * Instances of the class {@code Parser} are used to parse tokens into an AST structure.
+ * @coverage dart.engine.parser
  */
 class Parser {
   /**
    * The source being parsed.
    */
   Source _source;
   /**
    * The error listener that will be informed of any errors that are found during the parse.
    */
   AnalysisErrorListener _errorListener;
@@ skipping 279 matching lines @@
       return true;
     }
     Token token = skipTypeName(_currentToken);
     if (token == null) {
       return false;
     }
     token = skipSimpleIdentifier(token);
     if (token == null) {
       return false;
     }
-    TokenType type20 = token.type;
-    return identical(type20, TokenType.EQ) || identical(type20, TokenType.COMMA) || identical(type20, TokenType.SEMICOLON) || matches3(token, Keyword.IN);
+    TokenType type21 = token.type;
+    return identical(type21, TokenType.EQ) || identical(type21, TokenType.COMMA) || identical(type21, TokenType.SEMICOLON) || matches3(token, Keyword.IN);
   }
   /**
    * Return {@code true} if the current token appears to be the beginning of a switch member.
    * @return {@code true} if the current token appears to be the beginning of a switch member
    */
   bool isSwitchMember() {
     Token token = _currentToken;
     while (matches4(token, TokenType.IDENTIFIER) && matches4(token.next, TokenType.COLON)) {
       token = token.next.next;
     }
     if (identical(token.type, TokenType.KEYWORD)) {
-      Keyword keyword27 = ((token as KeywordToken)).keyword;
-      return identical(keyword27, Keyword.CASE) || identical(keyword27, Keyword.DEFAULT);
+      Keyword keyword29 = ((token as KeywordToken)).keyword;
+      return identical(keyword29, Keyword.CASE) || identical(keyword29, Keyword.DEFAULT);
     }
     return false;
   }
   /**
    * Compare the given tokens to find the token that appears first in the source being parsed. That
    * is, return the left-most of all of the tokens. The arguments are allowed to be {@code null}.
    * Return the token with the smallest offset, or {@code null} if there are no arguments or if all
    * of the arguments are {@code null}.
    * @param tokens the tokens being compared
    * @return the token with the smallest offset
@@ skipping 22 matching lines @@
    * @param identifier the identifier that can optionally appear in the current location
    * @return {@code true} if the current token matches the given identifier
    */
   bool matches2(String identifier) => identical(_currentToken.type, TokenType.IDENTIFIER) && _currentToken.lexeme == identifier;
   /**
    * Return {@code true} if the given token matches the given keyword.
    * @param token the token being tested
    * @param keyword the keyword that is being tested for
    * @return {@code true} if the given token matches the given keyword
    */
-  bool matches3(Token token, Keyword keyword35) => identical(token.type, TokenType.KEYWORD) && identical(((token as KeywordToken)).keyword, keyword35);
+  bool matches3(Token token, Keyword keyword37) => identical(token.type, TokenType.KEYWORD) && identical(((token as KeywordToken)).keyword, keyword37);
   /**
    * Return {@code true} if the given token has the given type.
    * @param token the token being tested
    * @param type the type of token that is being tested for
    * @return {@code true} if the given token has the given type
    */
-  bool matches4(Token token, TokenType type29) => identical(token.type, type29);
+  bool matches4(Token token, TokenType type30) => identical(token.type, type30);
   /**
    * Return {@code true} if the current token has the given type. Note that this method, unlike
    * other variants, will modify the token stream if possible to match a wider range of tokens. In
    * particular, if we are attempting to match a '>' and the next token is either a '>>' or '>>>',
    * the token stream will be re-written and {@code true} will be returned.
    * @param type the type of token that can optionally appear in the current location
    * @return {@code true} if the current token has the given type
    */
-  bool matches5(TokenType type30) {
+  bool matches5(TokenType type31) {
     TokenType currentType = _currentToken.type;
-    if (currentType != type30) {
-      if (identical(type30, TokenType.GT)) {
+    if (currentType != type31) {
+      if (identical(type31, TokenType.GT)) {
         if (identical(currentType, TokenType.GT_GT)) {
           int offset6 = _currentToken.offset;
           Token first = new Token(TokenType.GT, offset6);
           Token second = new Token(TokenType.GT, offset6 + 1);
           second.setNext(_currentToken.next);
           first.setNext(second);
           _currentToken.previous.setNext(first);
           _currentToken = first;
           return true;
         } else if (identical(currentType, TokenType.GT_EQ)) {
@@ skipping 713 matching lines @@
    * comment
    * @param sourceOffset the offset of the first character of the reference source
    * @return the comment reference that was parsed
    */
   CommentReference parseCommentReference(String referenceSource, int sourceOffset) {
     if (referenceSource.length == 0) {
       return null;
     }
     try {
       List<bool> errorFound = [false];
-      AnalysisErrorListener listener = new AnalysisErrorListener_6(errorFound);
+      AnalysisErrorListener listener = new AnalysisErrorListener_7(errorFound);
       StringScanner scanner = new StringScanner(null, referenceSource, listener);
       scanner.setSourceStart(1, 1, sourceOffset);
       Token firstToken = scanner.tokenize();
       if (!errorFound[0]) {
         Token newKeyword = null;
         if (matches3(firstToken, Keyword.NEW)) {
           newKeyword = firstToken;
           firstToken = firstToken.next;
         }
         if (matchesIdentifier2(firstToken)) {
@@ skipping 67 matching lines @@
    * <pre>
    * compilationUnit ::=
    * scriptTag? topLevelElement
    * topLevelElement ::=
    * directive
    * | topLevelDeclaration
    * </pre>
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseCompilationUnit2() {
-    Token firstToken = _currentToken.precedingComments;
-    if (firstToken == null) {
-      firstToken = _currentToken;
-    }
+    Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (matches5(TokenType.SCRIPT_TAG)) {
       scriptTag = new ScriptTag.full(andAdvance);
     }
     bool libraryDirectiveFound = false;
     bool partOfDirectiveFound = false;
     bool partDirectiveFound = false;
     bool directiveFoundAfterDeclaration = false;
     List<Directive> directives = new List<Directive>();
     List<CompilationUnitMember> declarations = new List<CompilationUnitMember>();
@@ skipping 78 matching lines @@
     if (matches(Keyword.CLASS)) {
       return parseClassDeclaration(commentAndMetadata, validateModifiersForClass(modifiers));
     } else if (matches(Keyword.TYPEDEF) && !matches4(peek(), TokenType.PERIOD) && !matches4(peek(), TokenType.LT)) {
       validateModifiersForTypedef(modifiers);
       return parseTypeAlias(commentAndMetadata);
     }
     if (matches(Keyword.VOID)) {
       TypeName returnType = parseReturnType();
       if ((matches(Keyword.GET) || matches(Keyword.SET)) && matchesIdentifier2(peek())) {
         validateModifiersForTopLevelFunction(modifiers);
-        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null, false);
+        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
       } else if (matches(Keyword.OPERATOR) && peek().isOperator()) {
         return null;
       } else if (matchesIdentifier() && matchesAny(peek(), [TokenType.OPEN_PAREN, TokenType.OPEN_CURLY_BRACKET, TokenType.FUNCTION])) {
         validateModifiersForTopLevelFunction(modifiers);
-        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null, false);
+        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
       } else {
         if (matchesIdentifier()) {
           if (matchesAny(peek(), [TokenType.EQ, TokenType.COMMA, TokenType.SEMICOLON])) {
             reportError(ParserErrorCode.VOID_VARIABLE, returnType, []);
             return new TopLevelVariableDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationList2(validateModifiersForTopLevelVariable(modifiers), null), expect2(TokenType.SEMICOLON));
           }
         }
         return null;
       }
     } else if ((matches(Keyword.GET) || matches(Keyword.SET)) && matchesIdentifier2(peek())) {
       validateModifiersForTopLevelFunction(modifiers);
-      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null, false);
+      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (matches(Keyword.OPERATOR) && peek().isOperator() && matches4(peek2(2), TokenType.OPEN_PAREN)) {
       return null;
     } else if (!matchesIdentifier()) {
       return null;
     } else if (matches4(peek(), TokenType.OPEN_PAREN)) {
       validateModifiersForTopLevelFunction(modifiers);
-      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null, false);
+      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (matchesAny(peek(), [TokenType.EQ, TokenType.COMMA, TokenType.SEMICOLON])) {
       return new TopLevelVariableDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationList2(validateModifiersForTopLevelVariable(modifiers), null), expect2(TokenType.SEMICOLON));
     }
     TypeName returnType = parseReturnType();
     if (matches(Keyword.GET) || matches(Keyword.SET)) {
       validateModifiersForTopLevelFunction(modifiers);
-      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType, false);
+      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType);
     } else if (!matchesIdentifier()) {
       return null;
     }
     if (matchesAny(peek(), [TokenType.OPEN_PAREN, TokenType.FUNCTION, TokenType.OPEN_CURLY_BRACKET])) {
       validateModifiersForTopLevelFunction(modifiers);
-      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType, false);
+      return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType);
     }
     return new TopLevelVariableDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationList2(validateModifiersForTopLevelVariable(modifiers), returnType), expect2(TokenType.SEMICOLON));
   }
   /**
    * Parse a conditional expression.
    * <pre>
    * conditionalExpression ::=
    * logicalOrExpression ('?' expressionWithoutCascade ':' expressionWithoutCascade)?
    * </pre>
    * @return the conditional expression that was parsed
@@ skipping 580 matching lines @@
           List<VariableDeclaration> variables = new List<VariableDeclaration>();
           SimpleIdentifier variableName = parseSimpleIdentifier();
           variables.add(new VariableDeclaration.full(null, null, variableName, null, null));
           variableList = new VariableDeclarationList.full(null, null, variables);
         } else if (isInitializedVariableDeclaration()) {
           variableList = parseVariableDeclarationList();
         } else {
           initialization = parseExpression2();
         }
         if (matches(Keyword.IN)) {
-          SimpleFormalParameter loopParameter = null;
+          DeclaredIdentifier loopVariable = null;
           if (variableList == null) {
             reportError4(ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH, []);
           } else {
             NodeList<VariableDeclaration> variables3 = variableList.variables;
             if (variables3.length > 1) {
               reportError4(ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH, [variables3.length.toString()]);
             }
             VariableDeclaration variable = variables3[0];
             if (variable.initializer != null) {
               reportError4(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, []);
             }
-            loopParameter = new SimpleFormalParameter.full(null, null, variableList.keyword, variableList.type, variable.name);
+            loopVariable = new DeclaredIdentifier.full(null, null, variableList.keyword, variableList.type, variable.name);
           }
           Token inKeyword = expect(Keyword.IN);
           Expression iterator = parseExpression2();
           Token rightParenthesis = expect2(TokenType.CLOSE_PAREN);
           Statement body = parseStatement2();
-          return new ForEachStatement.full(forKeyword, leftParenthesis, loopParameter, inKeyword, iterator, rightParenthesis, body);
+          return new ForEachStatement.full(forKeyword, leftParenthesis, loopVariable, inKeyword, iterator, rightParenthesis, body);
         }
       }
       Token leftSeparator = expect2(TokenType.SEMICOLON);
       Expression condition = null;
       if (!matches5(TokenType.SEMICOLON)) {
         condition = parseExpression2();
       }
       Token rightSeparator = expect2(TokenType.SEMICOLON);
       List<Expression> updaters = null;
       if (!matches5(TokenType.CLOSE_PAREN)) {
@@ skipping 62 matching lines @@
    * functionSignature functionBody
    * | returnType? getOrSet identifier formalParameterList functionBody
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' keyword, or {@code null} if the function is not external
    * @param returnType the return type, or {@code null} if there is no return type
    * @param isStatement {@code true} if the function declaration is being parsed as a statement
    * @return the function declaration that was parsed
    */
-  FunctionDeclaration parseFunctionDeclaration(CommentAndMetadata commentAndMetadata, Token externalKeyword, TypeName returnType, bool isStatement) {
+  FunctionDeclaration parseFunctionDeclaration(CommentAndMetadata commentAndMetadata, Token externalKeyword, TypeName returnType) {
     Token keyword = null;
     bool isGetter = false;
     if (matches(Keyword.GET) && !matches4(peek(), TokenType.OPEN_PAREN)) {
       keyword = andAdvance;
       isGetter = true;
     } else if (matches(Keyword.SET) && !matches4(peek(), TokenType.OPEN_PAREN)) {
       keyword = andAdvance;
     }
     SimpleIdentifier name = parseSimpleIdentifier();
     FormalParameterList parameters = null;
     if (!isGetter) {
       if (matches5(TokenType.OPEN_PAREN)) {
         parameters = parseFormalParameterList();
         validateFormalParameterList(parameters);
       } else {
         reportError4(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, []);
       }
     } else if (matches5(TokenType.OPEN_PAREN)) {
       reportError4(ParserErrorCode.GETTER_WITH_PARAMETERS, []);
       parseFormalParameterList();
     }
-    FunctionBody body = null;
+    FunctionBody body;
     if (externalKeyword == null) {
       body = parseFunctionBody(false, false);
-    }
-    if (!isStatement && matches5(TokenType.SEMICOLON)) {
-      reportError4(ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken.lexeme]);
-      advance();
+    } else {
+      body = new EmptyFunctionBody.full(expect2(TokenType.SEMICOLON));
     }
     return new FunctionDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, returnType, keyword, name, new FunctionExpression.full(parameters, body));
   }
   /**
    * Parse a function declaration statement.
    * <pre>
    * functionDeclarationStatement ::=
    * functionSignature functionBody
    * </pre>
    * @return the function declaration statement that was parsed
    */
   Statement parseFunctionDeclarationStatement() => parseFunctionDeclarationStatement2(parseCommentAndMetadata(), parseOptionalReturnType());
   /**
    * Parse a function declaration statement.
    * <pre>
    * functionDeclarationStatement ::=
    * functionSignature functionBody
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param returnType the return type, or {@code null} if there is no return type
    * @return the function declaration statement that was parsed
    */
-  Statement parseFunctionDeclarationStatement2(CommentAndMetadata commentAndMetadata, TypeName returnType) => new FunctionDeclarationStatement.full(parseFunctionDeclaration(commentAndMetadata, null, returnType, true));
+  Statement parseFunctionDeclarationStatement2(CommentAndMetadata commentAndMetadata, TypeName returnType) => new FunctionDeclarationStatement.full(parseFunctionDeclaration(commentAndMetadata, null, returnType));
   /**
    * Parse a function expression.
    * <pre>
    * functionExpression ::=
    * (returnType? identifier)? formalParameterList functionExpressionBody
    * </pre>
    * @return the function expression that was parsed
    */
   FunctionExpression parseFunctionExpression() {
     FormalParameterList parameters = parseFormalParameterList();
@@ skipping 548 matching lines @@
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
       if (matches4(peek(), TokenType.STRING)) {
         Token afterString = skipStringLiteral(_currentToken.next);
         if (afterString != null && identical(afterString.type, TokenType.COLON)) {
           return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
         }
       }
       return parseBlock();
     } else if (matches5(TokenType.KEYWORD) && !((_currentToken as KeywordToken)).keyword.isPseudoKeyword()) {
-      Keyword keyword28 = ((_currentToken as KeywordToken)).keyword;
-      if (identical(keyword28, Keyword.ASSERT)) {
+      Keyword keyword30 = ((_currentToken as KeywordToken)).keyword;
+      if (identical(keyword30, Keyword.ASSERT)) {
         return parseAssertStatement();
-      } else if (identical(keyword28, Keyword.BREAK)) {
+      } else if (identical(keyword30, Keyword.BREAK)) {
         return parseBreakStatement();
-      } else if (identical(keyword28, Keyword.CONTINUE)) {
+      } else if (identical(keyword30, Keyword.CONTINUE)) {
         return parseContinueStatement();
-      } else if (identical(keyword28, Keyword.DO)) {
+      } else if (identical(keyword30, Keyword.DO)) {
         return parseDoStatement();
-      } else if (identical(keyword28, Keyword.FOR)) {
+      } else if (identical(keyword30, Keyword.FOR)) {
         return parseForStatement();
-      } else if (identical(keyword28, Keyword.IF)) {
+      } else if (identical(keyword30, Keyword.IF)) {
         return parseIfStatement();
-      } else if (identical(keyword28, Keyword.RETURN)) {
+      } else if (identical(keyword30, Keyword.RETURN)) {
         return parseReturnStatement();
-      } else if (identical(keyword28, Keyword.SWITCH)) {
+      } else if (identical(keyword30, Keyword.SWITCH)) {
         return parseSwitchStatement();
-      } else if (identical(keyword28, Keyword.THROW)) {
+      } else if (identical(keyword30, Keyword.THROW)) {
         return new ExpressionStatement.full(parseThrowExpression(), expect2(TokenType.SEMICOLON));
-      } else if (identical(keyword28, Keyword.TRY)) {
+      } else if (identical(keyword30, Keyword.TRY)) {
         return parseTryStatement();
-      } else if (identical(keyword28, Keyword.WHILE)) {
+      } else if (identical(keyword30, Keyword.WHILE)) {
         return parseWhileStatement();
-      } else if (identical(keyword28, Keyword.VAR) || identical(keyword28, Keyword.FINAL)) {
+      } else if (identical(keyword30, Keyword.VAR) || identical(keyword30, Keyword.FINAL)) {
         return parseVariableDeclarationStatement();
-      } else if (identical(keyword28, Keyword.VOID)) {
+      } else if (identical(keyword30, Keyword.VOID)) {
         TypeName returnType = parseReturnType();
         if (matchesIdentifier() && matchesAny(peek(), [TokenType.OPEN_PAREN, TokenType.OPEN_CURLY_BRACKET, TokenType.FUNCTION])) {
           return parseFunctionDeclarationStatement2(commentAndMetadata, returnType);
         } else {
           if (matchesIdentifier()) {
             if (matchesAny(peek(), [TokenType.EQ, TokenType.COMMA, TokenType.SEMICOLON])) {
               reportError(ParserErrorCode.VOID_VARIABLE, returnType, []);
               return parseVariableDeclarationStatement();
             }
           }
           return null;
         }
-      } else if (identical(keyword28, Keyword.CONST)) {
+      } else if (identical(keyword30, Keyword.CONST)) {
         if (matchesAny(peek(), [TokenType.LT, TokenType.OPEN_CURLY_BRACKET, TokenType.OPEN_SQUARE_BRACKET, TokenType.INDEX])) {
           return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
         } else if (matches4(peek(), TokenType.IDENTIFIER)) {
           Token afterType = skipTypeName(peek());
           if (afterType != null) {
             if (matches4(afterType, TokenType.OPEN_PAREN) || (matches4(afterType, TokenType.PERIOD) && matches4(afterType.next, TokenType.IDENTIFIER) && matches4(afterType.next.next, TokenType.OPEN_PAREN))) {
               return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
             }
           }
         }
         return parseVariableDeclarationStatement();
-      } else if (identical(keyword28, Keyword.NEW) || identical(keyword28, Keyword.TRUE) || identical(keyword28, Keyword.FALSE) || identical(keyword28, Keyword.NULL) || identical(keyword28, Keyword.SUPER) || identical(keyword28, Keyword.THIS)) {
+      } else if (identical(keyword30, Keyword.NEW) || identical(keyword30, Keyword.TRUE) || identical(keyword30, Keyword.FALSE) || identical(keyword30, Keyword.NULL) || identical(keyword30, Keyword.SUPER) || identical(keyword30, Keyword.THIS)) {
         return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
       } else {
         return null;
       }
     } else if (matches5(TokenType.SEMICOLON)) {
       return parseEmptyStatement();
     } else if (isInitializedVariableDeclaration()) {
       return parseVariableDeclarationStatement();
     } else if (isFunctionDeclaration()) {
       return parseFunctionDeclarationStatement();
@@ skipping 27 matching lines @@
       thisKeyword = andAdvance;
       period = expect2(TokenType.PERIOD);
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     if (matches5(TokenType.OPEN_PAREN)) {
       if (thisKeyword != null) {
       }
       FormalParameterList parameters = parseFormalParameterList();
       return new FunctionTypedFormalParameter.full(commentAndMetadata.comment, commentAndMetadata.metadata, holder.type, identifier, parameters);
     }
-    TypeName type21 = holder.type;
-    if (type21 != null && matches3(type21.name.beginToken, Keyword.VOID)) {
-      reportError5(ParserErrorCode.VOID_PARAMETER, type21.name.beginToken, []);
+    TypeName type22 = holder.type;
+    if (type22 != null && matches3(type22.name.beginToken, Keyword.VOID)) {
+      reportError5(ParserErrorCode.VOID_PARAMETER, type22.name.beginToken, []);
     }
     if (thisKeyword != null) {
       return new FieldFormalParameter.full(commentAndMetadata.comment, commentAndMetadata.metadata, holder.keyword, holder.type, thisKeyword, period, identifier);
     }
     return new SimpleFormalParameter.full(commentAndMetadata.comment, commentAndMetadata.metadata, holder.keyword, holder.type, identifier);
   }
   /**
    * Parse an operator declaration.
    * <pre>
    * operatorDeclaration ::=
@@ skipping 1089 matching lines @@
    * actually creating a string literal or changing the current token. Return the token following
    * the string literal that was parsed, or {@code null} if the given token is not the first token
    * in a valid string literal.
    * <p>
    * This method must be kept in sync with {@link #parseStringInterpolation(Token)}.
    * @param startToken the token at which parsing is to begin
    * @return the string literal that was parsed
    */
   Token skipStringInterpolation(Token startToken) {
     Token token = startToken;
-    TokenType type22 = token.type;
-    while (identical(type22, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type22, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
-      if (identical(type22, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
+    TokenType type23 = token.type;
+    while (identical(type23, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type23, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
+      if (identical(type23, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         token = token.next;
-        type22 = token.type;
+        type23 = token.type;
         int bracketNestingLevel = 1;
         while (bracketNestingLevel > 0) {
-          if (identical(type22, TokenType.EOF)) {
+          if (identical(type23, TokenType.EOF)) {
             return null;
-          } else if (identical(type22, TokenType.OPEN_CURLY_BRACKET)) {
+          } else if (identical(type23, TokenType.OPEN_CURLY_BRACKET)) {
             bracketNestingLevel++;
-          } else if (identical(type22, TokenType.CLOSE_CURLY_BRACKET)) {
+          } else if (identical(type23, TokenType.CLOSE_CURLY_BRACKET)) {
             bracketNestingLevel--;
-          } else if (identical(type22, TokenType.STRING)) {
+          } else if (identical(type23, TokenType.STRING)) {
             token = skipStringLiteral(token);
             if (token == null) {
               return null;
             }
           } else {
             token = token.next;
           }
-          type22 = token.type;
+          type23 = token.type;
         }
         token = token.next;
-        type22 = token.type;
+        type23 = token.type;
       } else {
         token = token.next;
         if (token.type != TokenType.IDENTIFIER) {
           return null;
         }
         token = token.next;
       }
-      type22 = token.type;
-      if (identical(type22, TokenType.STRING)) {
+      type23 = token.type;
+      if (identical(type23, TokenType.STRING)) {
         token = token.next;
-        type22 = token.type;
+        type23 = token.type;
       }
     }
     return token;
   }
   /**
    * Parse a string literal, starting at the given token, without actually creating a string literal
    * or changing the current token. Return the token following the string literal that was parsed,
    * or {@code null} if the given token is not the first token in a valid string literal.
    * <p>
    * This method must be kept in sync with {@link #parseStringLiteral()}.
    * <pre>
    * stringLiteral ::=
    * MULTI_LINE_STRING+
    * | SINGLE_LINE_STRING+
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the string literal that was parsed
    */
   Token skipStringLiteral(Token startToken) {
     Token token = startToken;
     while (token != null && matches4(token, TokenType.STRING)) {
       token = token.next;
-      TokenType type23 = token.type;
-      if (identical(type23, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type23, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
+      TokenType type24 = token.type;
+      if (identical(type24, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type24, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
         token = skipStringInterpolation(token);
       }
     }
     if (identical(token, startToken)) {
       return null;
     }
     return token;
   }
   /**
    * Parse a list of type arguments, starting at the given token, without actually creating a type argument list
@@ skipping 444 matching lines @@
       reportError5(ParserErrorCode.EXTERNAL_TYPEDEF, modifiers.externalKeyword, []);
     }
     if (modifiers.finalKeyword != null) {
       reportError5(ParserErrorCode.FINAL_TYPEDEF, modifiers.finalKeyword, []);
     }
     if (modifiers.varKeyword != null) {
       reportError5(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword, []);
     }
   }
 }
-class AnalysisErrorListener_6 implements AnalysisErrorListener {
+class AnalysisErrorListener_7 implements AnalysisErrorListener {
   List<bool> errorFound;
-  AnalysisErrorListener_6(this.errorFound);
+  AnalysisErrorListener_7(this.errorFound);
   void onError(AnalysisError error) {
     errorFound[0] = true;
   }
 }
 /**
  * The enumeration {@code ParserErrorCode} defines the error codes used for errors detected by the
  * parser. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
+ * @coverage dart.engine.parser
  */
 class ParserErrorCode implements ErrorCode {
   static final ParserErrorCode ABSTRACT_CLASS_MEMBER = new ParserErrorCode.con2('ABSTRACT_CLASS_MEMBER', 0, "Members of classes cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_STATIC_METHOD = new ParserErrorCode.con2('ABSTRACT_STATIC_METHOD', 1, "Static methods cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_TOP_LEVEL_FUNCTION = new ParserErrorCode.con2('ABSTRACT_TOP_LEVEL_FUNCTION', 2, "Top-level functions cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_TOP_LEVEL_VARIABLE = new ParserErrorCode.con2('ABSTRACT_TOP_LEVEL_VARIABLE', 3, "Top-level variables cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_TYPEDEF = new ParserErrorCode.con2('ABSTRACT_TYPEDEF', 4, "Type aliases cannot be declared to be 'abstract'");
   static final ParserErrorCode BREAK_OUTSIDE_OF_LOOP = new ParserErrorCode.con2('BREAK_OUTSIDE_OF_LOOP', 5, "A break statement cannot be used outside of a loop or switch statement");
   static final ParserErrorCode CONST_AND_FINAL = new ParserErrorCode.con2('CONST_AND_FINAL', 6, "Members cannot be declared to be both 'const' and 'final'");
   static final ParserErrorCode CONST_AND_VAR = new ParserErrorCode.con2('CONST_AND_VAR', 7, "Members cannot be declared to be both 'const' and 'var'");
@@ skipping 84 matching lines @@
   static final ParserErrorCode WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER = new ParserErrorCode.con2('WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER', 92, "The default value of a positional parameter should be preceeded by '='");
   static final ParserErrorCode WRONG_TERMINATOR_FOR_PARAMETER_GROUP = new ParserErrorCode.con2('WRONG_TERMINATOR_FOR_PARAMETER_GROUP', 93, "Expected '%s' to close parameter group");
   static final ParserErrorCode VAR_CLASS = new ParserErrorCode.con2('VAR_CLASS', 94, "Classes cannot be declared to be 'var'");
   static final ParserErrorCode VAR_RETURN_TYPE = new ParserErrorCode.con2('VAR_RETURN_TYPE', 95, "The return type cannot be 'var'");
   static final ParserErrorCode VAR_TYPEDEF = new ParserErrorCode.con2('VAR_TYPEDEF', 96, "Type aliases cannot be declared to be 'var'");
   static final ParserErrorCode VOID_PARAMETER = new ParserErrorCode.con2('VOID_PARAMETER', 97, "Parameters cannot have a type of 'void'");
   static final ParserErrorCode VOID_VARIABLE = new ParserErrorCode.con2('VOID_VARIABLE', 98, "Variables cannot have a type of 'void'");
   static final List<ParserErrorCode> values = [ABSTRACT_CLASS_MEMBER, ABSTRACT_STATIC_METHOD, ABSTRACT_TOP_LEVEL_FUNCTION, ABSTRACT_TOP_LEVEL_VARIABLE, ABSTRACT_TYPEDEF, BREAK_OUTSIDE_OF_LOOP, CONST_AND_FINAL, CONST_AND_VAR, CONST_CLASS, CONST_METHOD, CONST_TYPEDEF, CONSTRUCTOR_WITH_RETURN_TYPE, CONTINUE_OUTSIDE_OF_LOOP, CONTINUE_WITHOUT_LABEL_IN_CASE, DIRECTIVE_AFTER_DECLARATION, DUPLICATE_LABEL_IN_SWITCH_STATEMENT, DUPLICATED_MODIFIER, EXPECTED_CASE_OR_DEFAULT, EXPECTED_LIST_OR_MAP_LITERAL, EXPECTED_STRING_LITERAL, EXPECTED_TOKEN, EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, EXTERNAL_AFTER_CONST, EXTERNAL_AFTER_FACTORY, EXTERNAL_AFTER_STATIC, EXTERNAL_CLASS, EXTERNAL_CONSTRUCTOR_WITH_BODY, EXTERNAL_FIELD, EXTERNAL_GETTER_WITH_BODY, EXTERNAL_METHOD_WITH_BODY, EXTERNAL_OPERATOR_WITH_BODY, EXTERNAL_SETTER_WITH_BODY, EXTERNAL_TYPEDEF, FACTORY_TOP_LEVEL_DECLARATION, FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, FINAL_AND_VAR, FINAL_CLASS, FINAL_CONSTRUCTOR, FINAL_METHOD, FINAL_TYPEDEF, GETTER_WITH_PARAMETERS, ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, IMPLEMENTS_BEFORE_EXTENDS, IMPLEMENTS_BEFORE_WITH, IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, INITIALIZED_VARIABLE_IN_FOR_EACH, INVALID_CODE_POINT, INVALID_COMMENT_REFERENCE, INVALID_HEX_ESCAPE, INVALID_OPERATOR_FOR_SUPER, INVALID_UNICODE_ESCAPE, LIBRARY_DIRECTIVE_NOT_FIRST, MISSING_ASSIGNABLE_SELECTOR, MISSING_CATCH_OR_FINALLY, MISSING_CLASS_BODY, MISSING_CONST_FINAL_VAR_OR_TYPE, MISSING_FUNCTION_BODY, MISSING_FUNCTION_PARAMETERS, MISSING_IDENTIFIER, MISSING_NAME_IN_LIBRARY_DIRECTIVE, MISSING_NAME_IN_PART_OF_DIRECTIVE, MISSING_TERMINATOR_FOR_PARAMETER_GROUP, MISSING_TYPEDEF_PARAMETERS, MISSING_VARIABLE_IN_FOR_EACH, MIXED_PARAMETER_GROUPS, MULTIPLE_EXTENDS_CLAUSES, MULTIPLE_IMPLEMENTS_CLAUSES, MULTIPLE_LIBRARY_DIRECTIVES, MULTIPLE_NAMED_PARAMETER_GROUPS, MULTIPLE_PART_OF_DIRECTIVES, MULTIPLE_POSITIONAL_PARAMETER_GROUPS, MULTIPLE_VARIABLES_IN_FOR_EACH, MULTIPLE_WITH_CLAUSES, NAMED_PARAMETER_OUTSIDE_GROUP, NON_CONSTRUCTOR_FACTORY, NON_IDENTIFIER_LIBRARY_NAME, NON_PART_OF_DIRECTIVE_IN_PART, NON_USER_DEFINABLE_OPERATOR, POSITIONAL_AFTER_NAMED_ARGUMENT, POSITIONAL_PARAMETER_OUTSIDE_GROUP, STATIC_AFTER_CONST, STATIC_AFTER_FINAL, STATIC_AFTER_VAR, STATIC_CONSTRUCTOR, STATIC_OPERATOR, STATIC_TOP_LEVEL_DECLARATION, UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP, UNEXPECTED_TOKEN, USE_OF_UNARY_PLUS_OPERATOR, WITH_BEFORE_EXTENDS, WITH_WITHOUT_EXTENDS, WRONG_SEPARATOR_FOR_NAMED_PARAMETER, WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER, WRONG_TERMINATOR_FOR_PARAMETER_GROUP, VAR_CLASS, VAR_RETURN_TYPE, VAR_TYPEDEF, VOID_PARAMETER, VOID_VARIABLE];
   String __name;
   int __ordinal = 0;
+  int get ordinal => __ordinal;
   /**
    * The severity of this error.
    */
   ErrorSeverity _severity;
   /**
    * The message template used to create the message to be displayed for this error.
    */
   String _message;
   /**
    * Initialize a newly created error code to have the given severity and message.
    * @param severity the severity of the error
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con1(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
-    _jtd_constructor_252_impl(___name, ___ordinal, severity2, message2);
+    _jtd_constructor_258_impl(___name, ___ordinal, severity2, message2);
   }
-  _jtd_constructor_252_impl(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
+  _jtd_constructor_258_impl(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
     __name = ___name;
     __ordinal = ___ordinal;
     this._severity = severity2;
     this._message = message2;
   }
   /**
    * Initialize a newly created error code to have the given message and a severity of ERROR.
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con2(String ___name, int ___ordinal, String message) {
-    _jtd_constructor_253_impl(___name, ___ordinal, message);
+    _jtd_constructor_259_impl(___name, ___ordinal, message);
   }
-  _jtd_constructor_253_impl(String ___name, int ___ordinal, String message) {
-    _jtd_constructor_252_impl(___name, ___ordinal, ErrorSeverity.ERROR, message);
+  _jtd_constructor_259_impl(String ___name, int ___ordinal, String message) {
+    _jtd_constructor_258_impl(___name, ___ordinal, ErrorSeverity.ERROR, message);
   }
   ErrorSeverity get errorSeverity => _severity;
   String get message => _message;
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
   bool needsRecompilation() => true;
   String toString() => __name;
 }
 /**
  * Instances of the class {link ToFormattedSourceVisitor} write a source representation of a visited
  * AST node (and all of it's children) to a writer.
@@ skipping 208 matching lines @@
     visit(node.type);
     visit7(".", node.name);
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     _writer.print("continue");
     visit7(" ", node.label);
     _writer.print(";");
     return null;
   }
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    visit8(node.keyword, " ");
+    visit6(node.type, " ");
+    visit(node.identifier);
+    return null;
+  }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
       _writer.print(" ");
       _writer.print(node.separator.lexeme);
       visit7(" ", node.defaultValue);
     }
     return null;
   }
   Object visitDoStatement(DoStatement node) {
@@ skipping 50 matching lines @@
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     visit8(node.keyword, " ");
     visit6(node.type, " ");
     _writer.print("this.");
     visit(node.identifier);
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
     _writer.print("for (");
-    visit(node.loopParameter);
+    visit(node.loopVariable);
     _writer.print(" in ");
     visit(node.iterator);
     _writer.print(") ");
     visit(node.body);
     return null;
   }
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
     NodeList<FormalParameter> parameters13 = node.parameters;
@@ skipping 555 matching lines @@
         for (int i = 0; i < size10; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }