dart2js cps: Use a strictness flag on Branch instead of rewriting.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../common/names.dart' show
     Names,
     Selectors;
 import '../compile_time_constants.dart' show
@@ skipping 755 matching lines @@
     //   let cont then() = [[thenPart]]; join(v, ...)
     //        and else() = [[elsePart]]; join(v, ...)
     //   in
     //     if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     thenContinuation.body = thenBuilder._root;
     elseContinuation.body = elseBuilder._root;
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(thenContinuation, elseContinuation,
-                new ir.Branch(new ir.IsTrue(condition),
-                              thenContinuation,
-                              elseContinuation))));
+                new ir.Branch.strict(condition,
+                                     thenContinuation,
+                                     elseContinuation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
@@ skipping 321 matching lines @@
     // If exactly one of the then and else continuation bodies is open (i.e.,
     // the other one has an exit on all paths), then Continuation.plug expects
     // that continuation to be listed first.  Arbitrarily use [then, else]
     // order otherwise.
     List<ir.Continuation> arms = !thenBuilder.isOpen && elseBuilder.isOpen
         ? <ir.Continuation>[elseContinuation, thenContinuation]
         : <ir.Continuation>[thenContinuation, elseContinuation];
 
     ir.Expression result =
         new ir.LetCont.many(arms,
-            new ir.Branch(new ir.IsTrue(condition),
-                          thenContinuation,
-                          elseContinuation));
+            new ir.Branch.strict(condition,
+                                 thenContinuation,
+                                 elseContinuation));
 
     JumpCollector join;  // Null if there is no join.
     if (thenBuilder.isOpen && elseBuilder.isOpen) {
       // There is a join-point continuation.  Build the term
       // 'let cont join(x, ...) = [] in Result' and plug invocations of the
       // join-point continuation into the then and else continuations.
       join = new ForwardJumpCollector(environment);
       thenBuilder.jumpTo(join);
       elseBuilder.jumpTo(join);
       result = new ir.LetCont(join.continuation, result);
@@ skipping 148 matching lines @@
     }
 
     // Create loop exit and body entry continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = outerBodyBuilder._root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch(new ir.IsTrue(condition),
-                          bodyContinuation,
-                          exitContinuation));
+            new ir.Branch.strict(condition,
+                                 bodyContinuation,
+                                 exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder._root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
@@ skipping 138 matching lines @@
     // let cont exit() = [ ]
     //      and body() = <<BODY>>
     // in branch condition (body, exit)
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder._root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch(new ir.IsTrue(condition),
-                          bodyContinuation,
-                          exitContinuation));
+            new ir.Branch.strict(condition,
+                                 bodyContinuation,
+                                 exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder._root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
@@ skipping 52 matching lines @@
     if (bodyBuilder.isOpen) bodyBuilder.jumpTo(loop);
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder._root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch(new ir.IsTrue(condition),
-                          bodyContinuation,
-                          exitContinuation));
+            new ir.Branch.strict(condition,
+                                 bodyContinuation,
+                                 exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder._root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
@@ skipping 63 matching lines @@
     IrBuilder exitBuilder = continueBuilder.makeDelimitedBuilder();
     exitBuilder.jumpTo(breakCollector);
     exitContinuation.body = exitBuilder._root;
     ir.Continuation repeatContinuation = new ir.Continuation([]);
     IrBuilder repeatBuilder = continueBuilder.makeDelimitedBuilder();
     repeatBuilder.jumpTo(loop);
     repeatContinuation.body = repeatBuilder._root;
 
     continueBuilder.add(
         new ir.LetCont.two(exitContinuation, repeatContinuation,
-            new ir.Branch(new ir.IsTrue(condition),
-                          repeatContinuation,
-                          exitContinuation)));
+            new ir.Branch.strict(condition,
+                                 repeatContinuation,
+                                 exitContinuation)));
     continueCollector.continuation.body = continueBuilder._root;
 
     // Construct the loop continuation (i.e., the body and condition).
     // <Loop> =
     // let cont continue(x, ...) =
     //   <Continue>
     // in [[body]]; continue(v, ...)
     loopBuilder.add(
         new ir.LetCont(continueCollector.continuation,
             bodyBuilder._root));
@@ skipping 43 matching lines @@
       }
 
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = thenBuilder._root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
       // A LetCont.many term has a hole as the body of the first listed
       // continuation, to be plugged by the translation.  Therefore put the
       // else continuation first.
       casesBuilder.add(
           new ir.LetCont.two(elseContinuation, thenContinuation,
-              new ir.Branch(new ir.IsTrue(condition),
-                            thenContinuation,
-                            elseContinuation)));
+              new ir.Branch.strict(condition,
+                                   thenContinuation,
+                                   elseContinuation)));
     }
 
     if (defaultCase != null) {
       defaultCase.buildBody(casesBuilder);
     }
     if (casesBuilder.isOpen) casesBuilder.jumpTo(join);
 
     casesBuilder.state.breakCollectors.removeLast();
 
     if (!join.isEmpty) {
@@ skipping 184 matching lines @@
 
         // Build the type test guarding this clause. We can share the
         // environment with the nested builder because this part cannot mutate
         // it.
         IrBuilder checkBuilder = builder.makeDelimitedBuilder(environment);
         ir.Primitive typeMatches =
             checkBuilder.buildTypeOperator(exceptionParameter,
                 clause.type,
                 isTypeTest: true);
         checkBuilder.add(new ir.LetCont.two(thenContinuation, elseContinuation,
-                new ir.Branch(new ir.IsTrue(typeMatches),
-                    thenContinuation,
-                    elseContinuation)));
+            new ir.Branch.strict(typeMatches,
+                                 thenContinuation,
+                                 elseContinuation)));
         catchBody = checkBuilder._root;
       }
       builder.add(catchBody);
 
       return <ir.Parameter>[exceptionParameter, traceParameter];
     }
 
     void leaveTryCatch(IrBuilder builder, JumpCollector join,
                        ir.Expression body) {
       // Add the binding for the join-point continuation and continue the
@@ skipping 326 matching lines @@
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
     add(new ir.LetCont(joinContinuation,
           new ir.LetCont.two(thenContinuation, elseContinuation,
-              new ir.Branch(new ir.IsTrue(condition),
-                            thenContinuation,
-                            elseContinuation))));
+              new ir.Branch.strict(condition,
+                                   thenContinuation,
+                                   elseContinuation))));
     return resultParameter;
   }
 
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
       {bool isLazyOr: false}) {
@@ skipping 37 matching lines @@
     rightFalseBuilder.jumpTo(join, rightFalse);
     ir.Continuation leftTrueContinuation = new ir.Continuation([]);
     ir.Continuation leftFalseContinuation = new ir.Continuation([]);
     ir.Continuation rightTrueContinuation = new ir.Continuation([]);
     ir.Continuation rightFalseContinuation = new ir.Continuation([]);
     rightTrueContinuation.body = rightTrueBuilder._root;
     rightFalseContinuation.body = rightFalseBuilder._root;
     // The right subexpression has two continuations.
     rightBuilder.add(
         new ir.LetCont.two(rightTrueContinuation, rightFalseContinuation,
-            new ir.Branch(new ir.IsTrue(rightValue),
-                          rightTrueContinuation,
-                          rightFalseContinuation)));
+            new ir.Branch.strict(rightValue,
+                                 rightTrueContinuation,
+                                 rightFalseContinuation)));
     // Depending on the operator, the left subexpression's continuations are
     // either the right subexpression or an invocation of the join-point
     // continuation.
     if (isLazyOr) {
       leftTrueContinuation.body = emptyBuilder._root;
       leftFalseContinuation.body = rightBuilder._root;
     } else {
       leftTrueContinuation.body = rightBuilder._root;
       leftFalseContinuation.body = emptyBuilder._root;
     }
 
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(leftTrueContinuation, leftFalseContinuation,
-                new ir.Branch(new ir.IsTrue(leftValue),
-                              leftTrueContinuation,
-                              leftFalseContinuation))));
+                new ir.Branch.strict(leftValue,
+                                     leftTrueContinuation,
+                                     leftFalseContinuation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   ir.Primitive buildIdentical(ir.Primitive x, ir.Primitive y,
                               {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.ApplyBuiltinOperator(
         ir.BuiltinOperator.Identical, <ir.Primitive>[x, y],
         sourceInformation));
   }
@@ skipping 555 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }