New analyzer snapshot.

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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 'java_core.dart';
@@ skipping 1440 matching lines @@
   /**
    * A flag indicating whether the parser is currently in the body of a loop.
    */
   bool _inLoop = false;
 
   /**
    * A flag indicating whether the parser is currently in a switch statement.
    */
   bool _inSwitch = false;
 
+  /**
+   * A flag indicating whether the parser is currently in a constructor field initializer, with no
+   * intervening parens, braces, or brackets.
+   */
+  bool _inInitializer = false;
+
   static String _HIDE = "hide";
 
   static String _OF = "of";
 
   static String _ON = "on";
 
   static String _NATIVE = "native";
 
   static String _SHOW = "show";
 
@@ skipping 151 matching lines @@
   ArgumentList parseArgumentList() {
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     List<Expression> arguments = new List<Expression>();
     if (_matches(TokenType.CLOSE_PAREN)) {
       return new ArgumentList(leftParenthesis, arguments, andAdvance);
     }
     //
     // Even though unnamed arguments must all appear before any named arguments, we allow them to
     // appear in any order so that we can recover faster.
     //
-    Expression argument = parseArgument();
-    arguments.add(argument);
-    bool foundNamedArgument = argument is NamedExpression;
-    bool generatedError = false;
-    while (_optional(TokenType.COMMA)) {
-      argument = parseArgument();
+    bool wasInInitializer = _inInitializer;
+    _inInitializer = false;
+    try {
+      Expression argument = parseArgument();
       arguments.add(argument);
-      if (foundNamedArgument) {
-        if (!generatedError && argument is! NamedExpression) {
-          // Report the error, once, but allow the arguments to be in any order in the AST.
-          _reportErrorForCurrentToken(ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT, []);
-          generatedError = true;
+      bool foundNamedArgument = argument is NamedExpression;
+      bool generatedError = false;
+      while (_optional(TokenType.COMMA)) {
+        argument = parseArgument();
+        arguments.add(argument);
+        if (foundNamedArgument) {
+          if (!generatedError && argument is! NamedExpression) {
+            // Report the error, once, but allow the arguments to be in any order in the AST.
+            _reportErrorForCurrentToken(ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT, []);
+            generatedError = true;
+          }
+        } else if (argument is NamedExpression) {
+          foundNamedArgument = true;
         }
-      } else if (argument is NamedExpression) {
-        foundNamedArgument = true;
       }
+      // TODO(brianwilkerson) Recovery: Look at the left parenthesis to see whether there is a
+      // matching right parenthesis. If there is, then we're more likely missing a comma and should
+      // go back to parsing arguments.
+      Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
+      return new ArgumentList(leftParenthesis, arguments, rightParenthesis);
+    } finally {
+      _inInitializer = wasInInitializer;
     }
-    // TODO(brianwilkerson) Recovery: Look at the left parenthesis to see whether there is a
-    // matching right parenthesis. If there is, then we're more likely missing a comma and should
-    // go back to parsing arguments.
-    Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
-    return new ArgumentList(leftParenthesis, arguments, rightParenthesis);
   }
 
   /**
    * Parse a bitwise or expression.
    *
    * <pre>
    * bitwiseOrExpression ::=
    *     bitwiseXorExpression ('|' bitwiseXorExpression)*
    *   | 'super' ('|' bitwiseXorExpression)+
    * </pre>
@@ skipping 1401 matching lines @@
     return false;
   }
 
   /**
    * Return `true` if the given token appears to be the beginning of a function expression.
    *
    * @param startToken the token that might be the start of a function expression
    * @return `true` if the given token appears to be the beginning of a function expression
    */
   bool _isFunctionExpression(Token startToken) {
+    // Function expressions aren't allowed in initializer lists.
+    if (_inInitializer) {
+      return false;
+    }
     Token afterParameters = _skipFormalParameterList(startToken);
     if (afterParameters == null) {
       return false;
     }
     return afterParameters.matchesAny([TokenType.OPEN_CURLY_BRACKET, TokenType.FUNCTION]);
   }
 
   /**
    * Return `true` if the given character is a valid hexadecimal digit.
    *
@@ skipping 412 matching lines @@
    *   | '.' identifier
    * </pre>
    *
    * @param prefix the expression preceding the selector
    * @param optional `true` if the selector is optional
    * @return the assignable selector that was parsed
    */
   Expression _parseAssignableSelector(Expression prefix, bool optional) {
     if (_matches(TokenType.OPEN_SQUARE_BRACKET)) {
       Token leftBracket = andAdvance;
-      Expression index = parseExpression2();
-      Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
-      return new IndexExpression.forTarget(prefix, leftBracket, index, rightBracket);
+      bool wasInInitializer = _inInitializer;
+      _inInitializer = false;
+      try {
+        Expression index = parseExpression2();
+        Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
+        return new IndexExpression.forTarget(prefix, leftBracket, index, rightBracket);
+      } finally {
+        _inInitializer = wasInInitializer;
+      }
     } else if (_matches(TokenType.PERIOD)) {
       Token period = andAdvance;
       return new PropertyAccess(prefix, period, parseSimpleIdentifier());
     } else {
       if (!optional) {
         // Report the missing selector.
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, []);
       }
       return prefix;
     }
@@ skipping 90 matching lines @@
    * @return the expression representing the cascaded method invocation
    */
   Expression _parseCascadeSection() {
     Token period = _expect(TokenType.PERIOD_PERIOD);
     Expression expression = null;
     SimpleIdentifier functionName = null;
     if (_matchesIdentifier()) {
       functionName = parseSimpleIdentifier();
     } else if (_currentToken.type == TokenType.OPEN_SQUARE_BRACKET) {
       Token leftBracket = andAdvance;
-      Expression index = parseExpression2();
-      Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
-      expression = new IndexExpression.forCascade(period, leftBracket, index, rightBracket);
-      period = null;
+      bool wasInInitializer = _inInitializer;
+      _inInitializer = false;
+      try {
+        Expression index = parseExpression2();
+        Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
+        expression = new IndexExpression.forCascade(period, leftBracket, index, rightBracket);
+        period = null;
+      } finally {
+        _inInitializer = wasInInitializer;
+      }
     } else {
       _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken, [_currentToken.lexeme]);
       functionName = _createSyntheticIdentifier();
     }
     if (_currentToken.type == TokenType.OPEN_PAREN) {
       while (_currentToken.type == TokenType.OPEN_PAREN) {
         if (functionName != null) {
           expression = new MethodInvocation(expression, period, functionName, parseArgumentList());
           period = null;
           functionName = null;
@@ skipping 189 matching lines @@
    * @param classKeyword the token representing the 'class' keyword
    * @return the class type alias that was parsed
    */
   ClassTypeAlias _parseClassTypeAlias(CommentAndMetadata commentAndMetadata, Token abstractKeyword, Token classKeyword) {
     SimpleIdentifier className = parseSimpleIdentifier();
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     Token equals = _expect(TokenType.EQ);
-    if (_matchesKeyword(Keyword.ABSTRACT)) {
-      abstractKeyword = andAdvance;
-    }
     TypeName superclass = parseTypeName();
     WithClause withClause = null;
     if (_matchesKeyword(Keyword.WITH)) {
       withClause = parseWithClause();
+    } else {
+      _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TOKEN, [Keyword.WITH.syntax]);
     }
     ImplementsClause implementsClause = null;
     if (_matchesKeyword(Keyword.IMPLEMENTS)) {
       implementsClause = parseImplementsClause();
     }
     Token semicolon;
     if (_matches(TokenType.SEMICOLON)) {
       semicolon = andAdvance;
     } else {
       if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
@@ skipping 378 matching lines @@
    */
   ConstructorFieldInitializer _parseConstructorFieldInitializer() {
     Token keyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       keyword = andAdvance;
       period = _expect(TokenType.PERIOD);
     }
     SimpleIdentifier fieldName = parseSimpleIdentifier();
     Token equals = _expect(TokenType.EQ);
-    Expression expression = parseConditionalExpression();
-    TokenType tokenType = _currentToken.type;
-    if (tokenType == TokenType.PERIOD_PERIOD) {
-      List<Expression> cascadeSections = new List<Expression>();
-      while (tokenType == TokenType.PERIOD_PERIOD) {
-        Expression section = _parseCascadeSection();
-        if (section != null) {
-          cascadeSections.add(section);
+    bool wasInInitializer = _inInitializer;
+    _inInitializer = true;
+    try {
+      Expression expression = parseConditionalExpression();
+      TokenType tokenType = _currentToken.type;
+      if (tokenType == TokenType.PERIOD_PERIOD) {
+        List<Expression> cascadeSections = new List<Expression>();
+        while (tokenType == TokenType.PERIOD_PERIOD) {
+          Expression section = _parseCascadeSection();
+          if (section != null) {
+            cascadeSections.add(section);
+          }
+          tokenType = _currentToken.type;
         }
-        tokenType = _currentToken.type;
+        expression = new CascadeExpression(expression, cascadeSections);
       }
-      expression = new CascadeExpression(expression, cascadeSections);
+      return new ConstructorFieldInitializer(keyword, period, fieldName, equals, expression);
+    } finally {
+      _inInitializer = wasInInitializer;
     }
-    return new ConstructorFieldInitializer(keyword, period, fieldName, equals, expression);
   }
 
   /**
    * Parse a continue statement.
    *
    * <pre>
    * continueStatement ::=
    *     'continue' identifier? ';'
    * </pre>
    *
@@ skipping 786 matching lines @@
       leftBracket.setNext(rightBracket);
       _currentToken.previous.setNext(leftBracket);
       _currentToken = _currentToken.next;
       return new ListLiteral(modifier, typeArguments, leftBracket, null, rightBracket);
     }
     // open
     Token leftBracket = _expect(TokenType.OPEN_SQUARE_BRACKET);
     if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
       return new ListLiteral(modifier, typeArguments, leftBracket, null, andAdvance);
     }
-    List<Expression> elements = new List<Expression>();
-    elements.add(parseExpression2());
-    while (_optional(TokenType.COMMA)) {
-      if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
-        return new ListLiteral(modifier, typeArguments, leftBracket, elements, andAdvance);
+    bool wasInInitializer = _inInitializer;
+    _inInitializer = false;
+    try {
+      List<Expression> elements = new List<Expression>();
+      elements.add(parseExpression2());
+      while (_optional(TokenType.COMMA)) {
+        if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
+          return new ListLiteral(modifier, typeArguments, leftBracket, elements, andAdvance);
+        }
+        elements.add(parseExpression2());
       }
-      elements.add(parseExpression2());
+      Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
+      return new ListLiteral(modifier, typeArguments, leftBracket, elements, rightBracket);
+    } finally {
+      _inInitializer = wasInInitializer;
     }
-    Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
-    return new ListLiteral(modifier, typeArguments, leftBracket, elements, rightBracket);
   }
 
   /**
    * Parse a list or map literal.
    *
    * <pre>
    * listOrMapLiteral ::=
    *     listLiteral
    *   | mapLiteral
    * </pre>
@@ skipping 48 matching lines @@
    * @param typeArguments the type arguments that were declared, or `null` if there are no
    *          type arguments
    * @return the map literal that was parsed
    */
   MapLiteral _parseMapLiteral(Token modifier, TypeArgumentList typeArguments) {
     Token leftBracket = _expect(TokenType.OPEN_CURLY_BRACKET);
     List<MapLiteralEntry> entries = new List<MapLiteralEntry>();
     if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
       return new MapLiteral(modifier, typeArguments, leftBracket, entries, andAdvance);
     }
-    entries.add(parseMapLiteralEntry());
-    while (_optional(TokenType.COMMA)) {
-      if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
-        return new MapLiteral(modifier, typeArguments, leftBracket, entries, andAdvance);
+    bool wasInInitializer = _inInitializer;
+    _inInitializer = false;
+    try {
+      entries.add(parseMapLiteralEntry());
+      while (_optional(TokenType.COMMA)) {
+        if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
+          return new MapLiteral(modifier, typeArguments, leftBracket, entries, andAdvance);
+        }
+        entries.add(parseMapLiteralEntry());
       }
-      entries.add(parseMapLiteralEntry());
+      Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
+      return new MapLiteral(modifier, typeArguments, leftBracket, entries, rightBracket);
+    } finally {
+      _inInitializer = wasInInitializer;
     }
-    Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
-    return new MapLiteral(modifier, typeArguments, leftBracket, entries, rightBracket);
   }
 
   /**
    * Parse a method declaration.
    *
    * <pre>
    * functionDeclaration ::=
    *     ('external' 'static'?)? functionSignature functionBody
    *   | 'external'? functionSignature ';'
    * </pre>
@@ skipping 517 matching lines @@
       return parsePrefixedIdentifier();
     } else if (_matchesKeyword(Keyword.NEW)) {
       return _parseNewExpression();
     } else if (_matchesKeyword(Keyword.CONST)) {
       return _parseConstExpression();
     } else if (_matches(TokenType.OPEN_PAREN)) {
       if (_isFunctionExpression(_currentToken)) {
         return parseFunctionExpression();
       }
       Token leftParenthesis = andAdvance;
-      Expression expression = parseExpression2();
-      Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
-      return new ParenthesizedExpression(leftParenthesis, expression, rightParenthesis);
+      bool wasInInitializer = _inInitializer;
+      _inInitializer = false;
+      try {
+        Expression expression = parseExpression2();
+        Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
+        return new ParenthesizedExpression(leftParenthesis, expression, rightParenthesis);
+      } finally {
+        _inInitializer = wasInInitializer;
+      }
     } else if (_matches(TokenType.LT)) {
       return _parseListOrMapLiteral(null);
     } else if (_matches(TokenType.QUESTION)) {
       return _parseArgumentDefinitionTest();
     } else if (_matchesKeyword(Keyword.VOID)) {
       //
       // Recover from having a return type of "void" where a return type is not expected.
       //
       // TODO(brianwilkerson) Improve this error message.
       _reportErrorForCurrentToken(ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken.lexeme]);
@@ skipping 182 matching lines @@
    *
    * @return the string literal that was parsed
    */
   StringInterpolation _parseStringInterpolation(Token string) {
     List<InterpolationElement> elements = new List<InterpolationElement>();
     bool hasMore = _matches(TokenType.STRING_INTERPOLATION_EXPRESSION) || _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER);
     elements.add(new InterpolationString(string, _computeStringValue(string.lexeme, true, !hasMore)));
     while (hasMore) {
       if (_matches(TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         Token openToken = andAdvance;
-        Expression expression = parseExpression2();
-        Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
-        elements.add(new InterpolationExpression(openToken, expression, rightBracket));
+        bool wasInInitializer = _inInitializer;
+        _inInitializer = false;
+        try {
+          Expression expression = parseExpression2();
+          Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
+          elements.add(new InterpolationExpression(openToken, expression, rightBracket));
+        } finally {
+          _inInitializer = wasInInitializer;
+        }
       } else {
         Token openToken = andAdvance;
         Expression expression = null;
         if (_matchesKeyword(Keyword.THIS)) {
           expression = new ThisExpression(andAdvance);
         } else {
           expression = parseSimpleIdentifier();
         }
         elements.add(new InterpolationExpression(openToken, expression, null));
       }
@@ skipping 3071 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }