dart2js cps: Insert refinements for identical(x, null) in condition.

pkg/compiler/lib/src/cps_ir/insert_refinements.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.optimization.insert_refinements;
 
 import 'optimizers.dart' show Pass;
 import 'shrinking_reductions.dart' show ParentVisitor;
 import 'cps_ir_nodes.dart';
 import '../types/types.dart';
@@ skipping 164 matching lines @@
       Primitive value = condition.value.definition;
       ClassElement classElement = condition.type.element;
       TypeMask type = new TypeMask.nonNullSubtype(classElement, world);
       Primitive refinedValue = new Refinement(value, type);
       pushRefinement(trueCont, refinedValue);
       push(falseCont);
       return;
     }
 
     // If the condition is comparison with a constant, promote the other value.
-    if (call is InvokeMethod && call.selector == Selectors.equals) {
-      Primitive first = call.arguments[0].definition;
-      Primitive second = call.arguments[1].definition;
+    // This can happen either for calls to `==` or `identical` calls, such
+    // as the ones inserted by the unsugaring pass.
+
+    void refineEquality(Primitive first,
+                        Primitive second,
+                        Continuation trueCont,
+                        Continuation falseCont) {
       if (second is Constant && second.value.isNull) {
         Refinement refinedTrue = new Refinement(first, nullType);
         Refinement refinedFalse = new Refinement(first, nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
-        return;
-      }
-      if (first is Constant && first.value.isNull) {
+      } else if (first is Constant && first.value.isNull) {
         Refinement refinedTrue = new Refinement(second, nullType);
         Refinement refinedFalse = new Refinement(second, nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
-        return;
+      } else {
+        push(trueCont);
+        push(falseCont);
       }
     }
 
+    if (call is InvokeMethod && call.selector == Selectors.equals) {
+      refineEquality(call.arguments[0].definition,
+                     call.arguments[1].definition,
+                     trueCont,
+                     falseCont);
+      return;
+    }
+
+    if (condition is ApplyBuiltinOperator &&
+        condition.operator == BuiltinOperator.Identical) {
+      refineEquality(condition.arguments[0].definition,
+                     condition.arguments[1].definition,
+                     trueCont,
+                     falseCont);
+      return;
+    }
+
     push(trueCont);
     push(falseCont);
   }
 
   @override
   Expression traverseLetCont(LetCont node) {
     for (Continuation cont in node.continuations) {
       if (cont.hasExactlyOneUse &&
           (cont.firstRef.parent is InvokeMethod ||
            cont.firstRef.parent is Branch)) {
         // Do not push the continuation here.
         // visitInvokeMethod and visitBranch will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }