Add support for parsing, but not capturing, assers in constructor initializer lists

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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2844 matching lines @@
               partDirectiveFound = true;
               return _parsePartDirective(commentAndMetadata);
             }
           } else {
             // Internal error: this method should not have been invoked if the
             // current token was something other than one of the above.
             throw new IllegalStateException(
                 "parseDirective invoked in an invalid state (currentToken = $_currentToken)");
           }
         }
+
         Directive directive = parseDirective();
         if (declarations.length > 0 && !directiveFoundAfterDeclaration) {
           _reportErrorForToken(ParserErrorCode.DIRECTIVE_AFTER_DECLARATION,
               directive.beginToken);
           directiveFoundAfterDeclaration = true;
         }
         directives.add(directive);
       } else if (type == TokenType.SEMICOLON) {
         // TODO(brianwilkerson) Consider moving this error detection into
         // _parseCompilationUnitMember (in the places where EXPECTED_EXECUTABLE
@@ skipping 1464 matching lines @@
     }
     _reportErrorForCurrentToken(
         ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_PAREN.lexeme]);
     // Recovery: Look to see whether there is a close paren that isn't matched
     // to an open paren and if so parse the list of arguments as normal.
     return new ArgumentList(_createSyntheticToken(TokenType.OPEN_PAREN), null,
         _createSyntheticToken(TokenType.CLOSE_PAREN));
   }
 
   /**
+   * Parse an assert within a constructor's initializer list. Return the assert.
+   *
+   * This method assumes that the current token matches `Keyword.ASSERT`.
+   *
+   *     assertInitializer ::=
+   *         'assert' '(' expression [',' expression] ')'
+   */
+  void _parseAssertInitializer() {
+    // return AssertInitializer

[scheglov, 2016/08/27 00:06:45]

I don't quite understand what this comment means.
Should it be TODO?

[Brian Wilkerson, 2016/08/27 00:32:44]

Done

It was a reminder to "Capture the syntax in the AST"

+    Token keyword = getAndAdvance();
+    Token leftParen = _expect(TokenType.OPEN_PAREN);
+    Expression expression = parseExpression2();
+    Token comma;
+    Expression message;
+    if (_matches(TokenType.COMMA)) {
+      comma = getAndAdvance();
+      message = parseExpression2();
+    }
+    Token rightParen = _expect(TokenType.CLOSE_PAREN);
+//    return new AssertInitializer(
+//        keyword, leftParen, expression, comma, message, rightParen);
+  }
+
+  /**
    * Parse an assert statement. Return the assert statement.
    *
    * This method assumes that the current token matches `Keyword.ASSERT`.
    *
    *     assertStatement ::=
    *         'assert' '(' expression [',' expression] ')' ';'
    */
   AssertStatement _parseAssertStatement() {
     Token keyword = getAndAdvance();
     Token leftParen = _expect(TokenType.OPEN_PAREN);
@@ skipping 1136 matching lines @@
             bodyAllowed = false;
             initializers.add(_parseRedirectingConstructorInvocation(true));
           } else {
             initializers.add(_parseConstructorFieldInitializer(true));
           }
         } else if (keyword == Keyword.SUPER) {
           initializers.add(_parseSuperConstructorInvocation());
         } else if (_matches(TokenType.OPEN_CURLY_BRACKET) ||
             _matches(TokenType.FUNCTION)) {
           _reportErrorForCurrentToken(ParserErrorCode.MISSING_INITIALIZER);
+        } else if (_matchesKeyword(Keyword.ASSERT)) {
+          _parseAssertInitializer();
         } else {
           initializers.add(_parseConstructorFieldInitializer(false));
         }
       } while (_optional(TokenType.COMMA));
       if (factoryKeyword != null) {
         _reportErrorForToken(
             ParserErrorCode.FACTORY_WITH_INITIALIZERS, factoryKeyword);
       }
     }
     ConstructorName redirectedConstructor = null;
@@ skipping 2760 matching lines @@
           _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_CASE_OR_DEFAULT);
           bool atEndOrNextMember() {
             TokenType type = _currentToken.type;
             if (type == TokenType.EOF ||
                 type == TokenType.CLOSE_CURLY_BRACKET) {
               return true;
             }
             Keyword keyword = _currentToken.keyword;
             return keyword == Keyword.CASE || keyword == Keyword.DEFAULT;
           }
+
           while (!atEndOrNextMember()) {
             _advance();
           }
         }
         type = _currentToken.type;
       }
       Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
       return new SwitchStatement(keyword, leftParenthesis, expression,
           rightParenthesis, leftBracket, members, rightBracket);
     } finally {
@@ skipping 323 matching lines @@
       bool isValidInUri(Token token) {
         TokenType type = token.type;
         return type == TokenType.COLON ||
             type == TokenType.SLASH ||
             type == TokenType.PERIOD ||
             type == TokenType.PERIOD_PERIOD ||
             type == TokenType.PERIOD_PERIOD_PERIOD ||
             type == TokenType.INT ||
             type == TokenType.DOUBLE;
       }
+
       while ((_tokenMatchesIdentifier(token) && !isKeywordAfterUri(token)) ||
           isValidInUri(token)) {
         token = token.next;
       }
       if (_tokenMatches(token, TokenType.SEMICOLON) ||
           isKeywordAfterUri(token)) {
         Token endToken = token.previous;
         token = _currentToken;
         int endOffset = token.end;
         StringBuffer buffer = new StringBuffer();
@@ skipping 1841 matching lines @@
    */
   const ParserErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }