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

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show ParentVisitor;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../io/source_information.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/universe.dart' show Selector;
@@ skipping 13 matching lines @@
   InterceptorEntity(this.interceptedVariable);
 
   String get name => interceptedVariable.name + '_';
 }
 
 
 /// Rewrites the initial CPS IR to make Dart semantics explicit and inserts
 /// special nodes that respect JavaScript behavior.
 ///
 /// Performs the following rewrites:
-///  - Rewrite [IsTrue] in a [Branch] to do boolean conversion.
 ///  - Add interceptors at call sites that use interceptor calling convention.
 ///  - Add explicit receiver argument for methods that are called in interceptor
 ///    calling convention.
 ///  - Convert two-parameter exception handlers to one-parameter ones.
 class UnsugarVisitor extends RecursiveVisitor {
   Glue _glue;
   ParentVisitor _parentVisitor = new ParentVisitor();
 
   Parameter thisParameter;
   Parameter explicitReceiverParameter;
@@ skipping 88 matching lines @@
     Primitive nullPrimitive = nullConstant;
     Primitive test = new ApplyBuiltinOperator(
         BuiltinOperator.Identical,
           <Primitive>[function.parameters.single, nullPrimitive],
           function.parameters.single.sourceInformation);
 
     Expression newBody =
         new LetCont.many(<Continuation>[returnFalse, originalBody],
             new LetPrim(nullPrimitive,
                 new LetPrim(test,
-                    new Branch(
-                        new IsTrue(test),
-                        returnFalse,
-                        originalBody))));
+                    new Branch.loose(test, returnFalse, originalBody))));
     function.body = newBody;
   }
 
   /// Insert a static call to [function] at the point of [node] with result
   /// [result].
   ///
   /// Rewrite [node] to
   ///
   /// let cont continuation(result) = node
   /// in invoke function arguments continuation
@@ skipping 117 matching lines @@
         ..interceptedClasses.addAll(_glue.getInterceptedClassesOn(selector));
       if (receiver.hint != null) {
         newReceiver.hint = new InterceptorEntity(receiver.hint);
       }
       insertLetPrim(newReceiver, contBinding);
     }
     node.arguments.insert(0, node.receiver);
     node.receiver = new Reference<Primitive>(newReceiver);
   }
 
-  processBranch(Branch node) {
-    // TODO(karlklose): implement the checked mode part of boolean conversion.
-    InteriorNode parent = node.parent;
-    IsTrue condition = node.condition;
-
-    // Do not rewrite conditions that are foreign code.
-    // It is redundant, and causes infinite recursion (if not optimized)
-    // in the implementation of identical, which itself contains a condition.
-    Primitive value = condition.value.definition;
-    if (value is Parameter && value.parent is Continuation) {
-      Continuation cont = value.parent;
-      if (cont.hasExactlyOneUse && cont.firstRef.parent is ForeignCode) {
-        ForeignCode foreign = cont.firstRef.parent;
-        if (foreign.type.containsOnlyBool(_glue.classWorld)) {
-          return;
-        }
-      }
-    }
-
-    Primitive t = trueConstant;
-    Primitive i = new ApplyBuiltinOperator(
-        BuiltinOperator.Identical,
-        <Primitive>[condition.value.definition, t],
-        condition.value.definition.sourceInformation);
-    LetPrim newNode = new LetPrim(t,
-        new LetPrim(i,
-            new Branch(new IsTrue(i),
-                node.trueContinuation.definition,
-                node.falseContinuation.definition)));
-    condition.value.unlink();
-    node.trueContinuation.unlink();
-    node.falseContinuation.unlink();
-    parent.body = newNode;
-  }
-
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }