Add support for assert statements with messages to the analyzer.

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 engine.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'ast.dart';
@@ skipping 556 matching lines @@
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitAssertStatement(AssertStatement node) {
     if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     }
+    if (identical(_oldNode, node.message)) {
+      return _parser.parseExpression2();
+    }
     return _notAChild(node);
   }
 
   @override
   AstNode visitAssignmentExpression(AssignmentExpression node) {
     if (identical(_oldNode, node.leftHandSide)) {
       // TODO(brianwilkerson) If the assignment is part of a cascade section,
       // then we don't have a single parse method that will work.
       // Otherwise, we can parse a conditional expression, but need to ensure
       // that the resulting expression is assignable.
@@ skipping 3784 matching lines @@
     } else if (expression is CascadeExpression) {
       _reportErrorForNode(
           ParserErrorCode.ASSERT_DOES_NOT_TAKE_CASCADE, expression);
     } else if (expression is ThrowExpression) {
       _reportErrorForNode(
           ParserErrorCode.ASSERT_DOES_NOT_TAKE_THROW, expression);
     } else if (expression is RethrowExpression) {
       _reportErrorForNode(
           ParserErrorCode.ASSERT_DOES_NOT_TAKE_RETHROW, expression);
     }
+    Token comma;
+    Expression message;
+    if (_matches(TokenType.COMMA)) {
+      comma = getAndAdvance();
+      message = parseExpression2();
+    }
     Token rightParen = _expect(TokenType.CLOSE_PAREN);
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new AssertStatement(
-        keyword, leftParen, expression, rightParen, semicolon);
+        keyword, leftParen, expression, comma, message, rightParen, semicolon);
   }
 
   /**
    * Parse an assignable expression. The [primaryAllowed] is `true` if the
    * expression is allowed to be a primary without any assignable selector.
    * Return the assignable expression that was parsed.
    *
    *     assignableExpression ::=
    *         primary (arguments* assignableSelector)+
    *       | 'super' unconditionalAssignableSelector
@@ skipping 5460 matching lines @@
     return false;
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
     AssertStatement toNode = this._toNode as AssertStatement;
     return _and(
         _isEqualTokens(node.assertKeyword, toNode.assertKeyword),
         _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
         _isEqualNodes(node.condition, toNode.condition),
+        _isEqualTokens(node.comma, toNode.comma),
+        _isEqualNodes(node.message, toNode.message),
         _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
         _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression toNode = this._toNode as AssignmentExpression;
     if (_and(
         _isEqualNodes(node.leftHandSide, toNode.leftHandSide),
         _isEqualTokens(node.operator, toNode.operator),
@@ skipping 1302 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }