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 2117 matching lines @@
    * during the parse.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * An [_errorListener] lock, if more than `0`, then errors are not reported.
    */
   int _errorListenerLock = 0;
 
   /**
+   * A flag indicating whether the parser is to parse asserts in the initializer
+   * list of a constructor.
+   */
+  bool _enableAssertInitializer = false;
+
+  /**
    * A flag indicating whether the parser is to parse the async support.
    */
   bool _parseAsync = true;
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   bool _parseFunctionBodies = true;
 
   /**
@@ skipping 47 matching lines @@
   Parser(this._source, this._errorListener);
 
   /**
    * Set the token with which the parse is to begin to the given [token].
    */
   void set currentToken(Token token) {
     this._currentToken = token;
   }
 
   /**
+   * Return `true` if the parser is to parse asserts in the initializer list of
+   * a constructor.
+   */
+  bool get enableAssertInitializer => _enableAssertInitializer;
+
+  /**
+   * Set whether the parser is to parse asserts in the initializer list of a
+   * constructor to match the given [enable] flag.
+   */
+  void set enableAssertInitializer(bool enable) {
+    _enableAssertInitializer = enable;
+  }
+
+  /**
    * Return `true` if the current token is the first token of a return type that
    * is followed by an identifier, possibly followed by a list of type
    * parameters, followed by a left-parenthesis. This is used by
    * [_parseTypeAlias] to determine whether or not to parse a return type.
    */
   @deprecated
   bool get hasReturnTypeInTypeAlias {
     Token next = _skipReturnType(_currentToken);
     if (next == null) {
       return false;
@@ skipping 640 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() {
+    // TODO(brianwilkerson) Capture the syntax in the AST using a new class,
+    // such as AssertInitializer
+    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 (_enableAssertInitializer &&
+            _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;
 }