kernel->ssa: implement assert statements

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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 659 matching lines @@
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
     assert(invariant(functionElement, !function.modifiers.isExternal));
 
     // If [functionElement] is `operator==` we explicitly add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
-        handleIf(function, visitCondition: () {
-          HParameterValue parameter = parameters.values.first;
-          push(new HIdentity(parameter, graph.addConstantNull(compiler), null,
-              backend.boolType));
-        }, visitThen: () {
-          closeAndGotoExit(new HReturn(graph.addConstantBool(false, compiler),
-              sourceInformationBuilder.buildImplicitReturn(functionElement)));
-        },
+        handleIf(
+            node: function,
+            visitCondition: () {
+              HParameterValue parameter = parameters.values.first;
+              push(new HIdentity(parameter, graph.addConstantNull(compiler),
+                  null, backend.boolType));
+            },
+            visitThen: () {
+              closeAndGotoExit(new HReturn(
+                  graph.addConstantBool(false, compiler),
+                  sourceInformationBuilder
+                      .buildImplicitReturn(functionElement)));
+            },
             visitElse: null,
             sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
     }
     if (const bool.fromEnvironment('unreachable-throw')) {
       var emptyParameters =
           parameters.values.where((p) => p.instructionType.isEmpty);
       if (emptyParameters.length > 0) {
         addComment('${emptyParameters} inferred as [empty]');
         pushInvokeStatic(function.body, helpers.assertUnreachableMethod, []);
@@ skipping 954 matching lines @@
       visit(node.condition);
       pushInvokeStatic(node, helpers.assertTest, [pop()]);
     }
 
     void fail() {
       visit(node.message);
       pushInvokeStatic(node, helpers.assertThrow, [pop()]);
       pop();
     }
 
-    handleIf(node, visitCondition: buildCondition, visitThen: fail);
+    handleIf(node: 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) {
@@ skipping 274 matching lines @@
     if (node.isThis()) {
       visitThisGet(node);
     } else {
       reporter.internalError(
           node, "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
-    handleIf(node,
+    handleIf(
+        node: node,
         visitCondition: () => visit(node.condition),
         visitThen: () => visit(node.thenPart),
         visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
         sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
-  void handleIf(ast.Node diagnosticNode,
-      {void visitCondition(),
-      void visitThen(),
-      void visitElse(),
-      SourceInformation sourceInformation}) {
-    SsaBranchBuilder branchBuilder =
-        new SsaBranchBuilder(this, compiler, diagnosticNode);
-    branchBuilder.handleIf(visitCondition, visitThen, visitElse,
-        sourceInformation: sourceInformation);
-  }
-
   @override
   void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleIfNull(() => visit(left), () => visit(right));
   }
 
   /// Optimizes logical binary where the left is also a logical binary.
   ///
   /// This method transforms the operator by optimizing the case where [left] is
   /// a logical "and" or logical "or". Then it uses [branchBuilder] to build the
@@ skipping 4168 matching lines @@
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
             code, backend.boolType, [localsHandler.readLocal(switchTarget)],
             nativeBehavior: native.NativeBehavior.PURE));
       }
 
-      handleIf(node,
+      handleIf(
+          node: node,
           visitCondition: buildCondition,
           visitThen: buildLoop,
           visitElse: () => {});
     }
   }
 
   /**
    * Creates a switch statement.
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
@@ skipping 321 matching lines @@
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
           closeAndGotoExit(new HThrow(exception, exception.sourceInformation,
               isRethrow: true));
         } else {
           ast.CatchBlock newBlock = link.head;
-          handleIf(node, visitCondition: () {
-            pushCondition(newBlock);
-          }, visitThen: visitThen, visitElse: visitElse);
+          handleIf(
+              node: node,
+              visitCondition: () {
+                pushCondition(newBlock);
+              },
+              visitThen: visitThen,
+              visitElse: visitElse);
         }
       }
 
       ast.CatchBlock firstBlock = link.head;
-      handleIf(node, visitCondition: () {
-        pushCondition(firstBlock);
-      }, visitThen: visitThen, visitElse: visitElse);
+      handleIf(
+          node: node,
+          visitCondition: () {
+            pushCondition(firstBlock);
+          },
+          visitThen: visitThen,
+          visitElse: visitElse);
       if (!isAborted()) endCatchBlock = close(new HGoto());
 
       rethrowableException = oldRethrowableException;
       tryInstruction.catchBlock = startCatchBlock;
       catchGraph = new SubGraph(startCatchBlock, lastOpenedBlock);
     }
 
     SubGraph finallyGraph = null;
     if (node.finallyBlock != null) {
       localsHandler = new LocalsHandler.from(savedLocals);
@@ skipping 515 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.helpers.DynamicRuntimeType;
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, closedWorld)));
   }
 }