Add optional message to assert in Dart2js - continued

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 2590 matching lines @@
   void visit(ast.Node node) {
     if (node != null) node.accept(this);
   }
 
   /// Visit [node] and pop the resulting [HInstruction].
   HInstruction visitAndPop(ast.Node node) {
     node.accept(this);
     return pop();
   }
 
+  visitAssert(ast.Assert node) {
+    if (!compiler.enableUserAssertions) return;
+
+    if (!node.hasMessage) {
+      // Generate:
+      //
+      //     assertHelper(condition);
+      //
+      visit(node.condition);
+      pushInvokeStatic(node, backend.assertHelperMethod, [pop()]);
+      pop();
+      return;
+    }
+    // Assert has message. Generate:
+    //
+    //     if (assertTest(condition)) assertThrow(message);
+    //
+    void buildCondition() {
+      visit(node.condition);
+      pushInvokeStatic(node, backend.assertTestMethod, [pop()]);
+    }
+    void fail() {
+      visit(node.message);
+      pushInvokeStatic(node, backend.assertThrowMethod, [pop()]);
+      pop();
+    }
+    handleIf(node,
+             visitCondition: buildCondition,
+             visitThen: fail);
+  }
+
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return;  // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (!stack.isEmpty) {
@@ skipping 2555 matching lines @@
       DartType instance = type.asInstanceOf(supertype.element);
       compiler.types.checkTypeVariableBounds(instance,
           addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
-  @override
-  visitAssert(ast.Send node, ast.Node expression, _) {
-    if (!compiler.enableUserAssertions) {
-      stack.add(graph.addConstantNull(compiler));
-      return;
-    }
-    assert(invariant(node, node.arguments.tail.isEmpty,
-        message: "Invalid assertion: $node"));
-    generateStaticFunctionInvoke(
-        node, backend.assertMethod, CallStructure.ONE_ARG);
-  }
-
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
       ast.Send node,
       FunctionElement function,
       CallStructure callStructure) {
     List<HInstruction> inputs = makeStaticArgumentList(
@@ skipping 3096 matching lines @@
   void visitConstantInvoke(
     ast.Send node,
     ConstantExpression constant,
     ast.NodeList arguments,
     CallStructure callStreucture,
     _) {
     visitNode(node);
   }
 
   @override
-  void errorInvalidAssert(
-      ast.Send node,
-      ast.NodeList arguments,
-      _) {
-    visitNode(node);
-  }
-
-  @override
   void errorUndefinedBinaryExpression(
       ast.Send node,
       ast.Node left,
       ast.Operator operator,
       ast.Node right,
       _) {
     visitNode(node);
   }
 
   @override
@@ skipping 608 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }