Add support for assert statements with messages to the analyzer.

pkg/analyzer/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
 
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 638 matching lines @@
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The condition that is being asserted to be `true`.
    */
   Expression _condition;
 
   /**
+   * The comma, if a message expression was supplied.  Otherwise `null`.
+   */
+  Token comma;
+
+  /**
+   * The message to report if the assertion fails.  `null` if no message was
+   * supplied.
+   */
+  Expression _message;
+
+  /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created assert statement.
    */
-  AssertStatement(this.assertKeyword, this.leftParenthesis,
-      Expression condition, this.rightParenthesis, this.semicolon) {
+  AssertStatement(
+      this.assertKeyword,
+      this.leftParenthesis,
+      Expression condition,
+      this.comma,
+      Expression message,
+      this.rightParenthesis,
+      this.semicolon) {
     _condition = _becomeParentOf(condition);
+    _message = _becomeParentOf(message);
   }
 
   @override
   Token get beginToken => assertKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(assertKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
+    ..add(comma)
+    ..add(_message)
     ..add(rightParenthesis)
     ..add(semicolon);
 
   /**
    * Return the condition that is being asserted to be `true`.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition that is being asserted to be `true` to the given
@@ skipping 13 matching lines @@
   Token get keyword => assertKeyword;
 
   /**
    * Set the token representing the 'assert' keyword to the given [token].
    */
   @deprecated // Use "this.assertKeyword"
   set keyword(Token token) {
     assertKeyword = token;
   }
 
+  /**
+   * Return the messasge to report if the assertion fails.

[scheglov, 2015/11/24 23:01:24]

messasge -> message

[Paul Berry, 2015/11/24 23:54:39]

Done.

+   */
+  Expression get message => _message;
+
+  /**
+   * Set the message to report if the assertion fails to the given
+   * [expression].
+   */
+  void set message(Expression expression) {
+    _message = _becomeParentOf(expression);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
+    _safelyVisitChild(message, visitor);
   }
 }
 
 /**
  * An assignment expression.
  *
  * > assignmentExpression ::=
  * >     [Expression] operator [Expression]
  */
 class AssignmentExpression extends Expression {
@@ skipping 297 matching lines @@
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(
       cloneNode(node.expression),
       cloneToken(node.asOperator),
       cloneNode(node.type));
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(
       cloneToken(node.assertKeyword),
       cloneToken(node.leftParenthesis),
       cloneNode(node.condition),
+      cloneToken(node.comma),
+      cloneNode(node.message),
       cloneToken(node.rightParenthesis),
       cloneToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) =>
       new AssignmentExpression(cloneNode(node.leftHandSide),
           cloneToken(node.operator), cloneNode(node.rightHandSide));
 
   @override
   AwaitExpression visitAwaitExpression(AwaitExpression node) =>
@@ skipping 836 matching lines @@
         isEqualTokens(node.asOperator, other.asOperator) &&
         isEqualNodes(node.type, other.type);
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
     AssertStatement other = _other as AssertStatement;
     return isEqualTokens(node.assertKeyword, other.assertKeyword) &&
         isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
         isEqualNodes(node.condition, other.condition) &&
+        isEqualTokens(node.comma, other.comma) &&
+        isEqualNodes(node.message, other.message) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression other = _other as AssignmentExpression;
     return isEqualNodes(node.leftHandSide, other.leftHandSide) &&
         isEqualTokens(node.operator, other.operator) &&
         isEqualNodes(node.rightHandSide, other.rightHandSide);
@@ skipping 7882 matching lines @@
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(
       _mapToken(node.assertKeyword),
       _mapToken(node.leftParenthesis),
       _cloneNode(node.condition),
+      _mapToken(node.comma),
+      _cloneNode(node.message),
       _mapToken(node.rightParenthesis),
       _mapToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(
         _cloneNode(node.leftHandSide),
         _mapToken(node.operator),
         _cloneNode(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
@@ skipping 3215 matching lines @@
     }
     return visitNode(node);
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
     if (identical(node.condition, _oldNode)) {
       node.condition = _newNode as Expression;
       return true;
     }
+    if (identical(node._message, _oldNode)) {
+      node.message = _newNode as Expression;
+      return true;
+    }
     return visitNode(node);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     if (identical(node.leftHandSide, _oldNode)) {
       node.leftHandSide = _newNode as Expression;
       return true;
     } else if (identical(node.rightHandSide, _oldNode)) {
       node.rightHandSide = _newNode as Expression;
@@ skipping 4987 matching lines @@
     _visitNode(node.expression);
     _writer.print(" as ");
     _visitNode(node.type);
     return null;
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
     _writer.print("assert (");
     _visitNode(node.condition);
+    if (node.message != null) {
+      _writer.print(', ');
+      _visitNode(node.message);
+    }
     _writer.print(");");
     return null;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
@@ skipping 2597 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }