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

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

 // Copyright (c) 2015, 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 cps_ir.cps_fragment;
 
 import 'cps_ir_nodes.dart';
 import '../constants/values.dart';
 import '../universe/universe.dart' show Selector;
 import '../types/types.dart' show TypeMask;
@@ skipping 15 matching lines @@
 /// Call `cont` with `obj.field + 1` as argument:
 ///
 ///   CpsFragment cps = new CpsFragment();
 ///   var fieldValue = cps.letPrim(new GetField(obj, field));
 ///   var plusOne = cps.applyBuiltin(BuiltinOperator.NumAdd,
 ///                                  [fieldValue, cps.makeOne()]);
 ///   cps.invokeContinuation(cont, [plusOne]);
 ///
 /// If `condition` is true then invoke `cont1`, else `cont2`.
 ///
-///   cps.ifTrue(condition).invokeContinuation(cont1, []);
+///   cps.ifTruthy(condition).invokeContinuation(cont1, []);
 ///   cps.invokeContinuation(cont2, []);
 ///
 /// If `condition` is true then invoke `cont` with a bound primitive:
 ///
-///   CpsFragment branch = cps.ifTrue(condition);
+///   CpsFragment branch = cps.ifTruthy(condition);
 ///   branch.invokeContinuation(cont, [branch.letPrim(arg)]);
 ///
 /// Loop and call a method until it returns false:
 ///
 ///   Continuation loop = cps.beginLoop();
 ///   var result = cps.invokeMethod(receiver, selector, ...);
-///   cps.ifFalse(result).invokeContinuation(exit, []);
+///   cps.ifFalsy(result).invokeContinuation(exit, []);
 ///   cps.continueLoop(loop);
 ///
 class CpsFragment {
   /// The root of the IR built using this fragment.
   Expression root;
 
   /// Node whose body is the hole in this CPS fragment. May be null.
   InteriorNode context;
 
   /// Source information to attach to every IR node created in the fragment.
@@ skipping 132 matching lines @@
   /// This closes the fragment; no more nodes may be inserted.
   void continueLoop(Continuation cont, [List<Primitive> updatedLoopVariables]) {
     put(new InvokeContinuation(cont, updatedLoopVariables, isRecursive: true));
   }
 
   /// Branch on [condition].
   ///
   /// Returns a new fragment for the 'then' branch.
   ///
   /// The 'else' branch becomes the new hole.
-  CpsFragment ifTrue(Primitive condition) {
+  CpsFragment ifTruthy(Primitive condition) {
     Continuation trueCont = new Continuation(<Parameter>[]);
     Continuation falseCont = new Continuation(<Parameter>[]);
     put(new LetCont.two(trueCont, falseCont,
-            new Branch(new IsTrue(condition), trueCont, falseCont)));
+            new Branch.loose(condition, trueCont, falseCont)));
     context = falseCont;
     return new CpsFragment(sourceInformation, trueCont);
   }
 
   /// Branch on [condition].
   ///
   /// Returns a new fragment for the 'else' branch.
   ///
   /// The 'then' branch becomes the new hole.
-  CpsFragment ifFalse(Primitive condition) {
+  CpsFragment ifFalsy(Primitive condition) {
     Continuation trueCont = new Continuation(<Parameter>[]);
     Continuation falseCont = new Continuation(<Parameter>[]);
     put(new LetCont.two(trueCont, falseCont,
-            new Branch(new IsTrue(condition), trueCont, falseCont)));
+            new Branch.loose(condition, trueCont, falseCont)));
     context = trueCont;
     return new CpsFragment(sourceInformation, falseCont);
   }
 
   /// Create a new empty continuation and bind it here.
   ///
   /// Convenient for making a join point where multiple branches
   /// meet later.
   ///
   /// The LetCont body becomes the new hole.
@@ skipping 61 matching lines @@
     letPrim(new SetMutable(variable, value));
   }
 
   /// Declare a new mutable variable.
   void letMutable(MutableVariable variable, Primitive initialValue) {
     LetMutable let = new LetMutable(variable, initialValue);
     put(let);
     context = let;
   }
 }