dart2js cps: Check strictness flag in redundant join eliminator.

pkg/compiler/lib/src/cps_ir/redundant_join.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 dart2js.cps_ir.redundant_join_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminates redundant join points.
@@ skipping 91 matching lines @@
     // of times each branch is hit.
     // We know all callers are InvokeContinuations because they are the only
     // valid uses of a multi-use continuation.
     int trueHits = 0, falseHits = 0;
     InvokeContinuation trueCall, falseCall;
     for (Reference ref = branchCont.firstRef; ref != null; ref = ref.next) {
       InvokeContinuation invoke = ref.parent;
       Primitive argument = invoke.arguments[parameterIndex].definition;
       if (argument is! Constant) return; // Branching condition is unknown.
       Constant constant = argument;
-      if (isFalsyConstant(constant.value)) {
+      if (isTruthyConstant(constant.value, strict: branch.isStrictCheck)) {
+        ++trueHits;
+        trueCall = invoke;
+      } else {
         ++falseHits;
         falseCall = invoke;
-      } else {
-        ++trueHits;
-        trueCall = invoke;
       }
     }
 
     // The optimization is now known to be safe, but it only pays off if
     // one of the callers can inline its target, since otherwise we end up
     // replacing a boolean variable with a labeled break.
     // TODO(asgerf): The labeled break might be better? Evaluate.
     if (!(trueHits == 1 && !trueCall.isEscapingTry ||
           falseHits == 1 && !falseCall.isEscapingTry)) {
       return;
@@ skipping 47 matching lines @@
     // Rewrite every invocation of branchCont to call either the true or false
     // branch directly. Since these were lifted out above branchCont, they are
     // now in scope.
     // Since trueCont and falseCont were branch targets, they originally
     // had no parameters, and so after the lifting, their parameters are
     // exactly the same as those accepted by branchCont.
     while (branchCont.firstRef != null) {
       Reference reference = branchCont.firstRef;
       InvokeContinuation invoke = branchCont.firstRef.parent;
       Constant condition = invoke.arguments[parameterIndex].definition;
-      if (isFalsyConstant(condition.value)) {
+      if (isTruthyConstant(condition.value, strict: branch.isStrictCheck)) {
+        invoke.continuation.changeTo(trueCont);
+      } else {
         invoke.continuation.changeTo(falseCont);
-      } else {
-        invoke.continuation.changeTo(trueCont);
       }
       assert(branchCont.firstRef != reference);
     }
 
     // Remove the now-unused branchCont continuation.
     assert(branchCont.hasNoUses);
     branch.trueContinuation.unlink();
     branch.falseContinuation.unlink();
     outerLetCont.continuations.remove(branchCont);
     if (outerLetCont.continuations.isEmpty) {
@@ skipping 66 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }