dart2js cps: Always use interceptors and type tags for 'is' checks.

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

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 // TODO(karlklose): share the [ParentVisitor].
 import '../../cps_ir/optimizers.dart';
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 import '../../elements/elements.dart' show
     ClassElement,
@@ skipping 244 matching lines @@
       newReceiver = new Interceptor(receiver, interceptedClasses);
       insertLetPrim(newReceiver, node);
     }
 
     node.arguments.insert(0, node.receiver);
     node.callingConvention = CallingConvention.JS_INTERCEPTED;
     assert(node.isValid);
     node.receiver = new Reference<Primitive>(newReceiver);
   }
 
+  processTypeOperator(TypeOperator node) {

[karlklose, 2015/05/22 07:40:49]

I think we should do this in the IR builder. Long term we should merge all of
the unsugar rewrites into the IR builder.

[asgerf, 2015/05/22 12:31:36]

I completely agree. There is a strange limbo in the time between building and
unsugaring where the IR doesn't seem to have clear semantics.

+    // Intercept the receiver to type operators.
+    // We don't have any type information here, so we use the set of all
+    // intercepted classes to be safe.
+    _glue.registerSpecializedGetInterceptor(_glue.interceptedClasses);
+    Primitive interceptor =
+        new Interceptor(node.receiver.definition, _glue.interceptedClasses);
+    insertLetPrim(interceptor, node);
+    node.receiver.unlink();
+    node.receiver = new Reference<Primitive>(interceptor);
+  }
+
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (_glue.isInterceptedMethod(node.target)) {
       Primitive nullPrim = nullConstant;
       insertLetPrim(nullPrim, node);
       node.arguments.insert(0, node.receiver);
       // TODO(sra): `null` is not adequate.  Interceptors project the class
       // hierarchy onto an interceptor hierarchy.  A super call that does a
       // method call will use the javascript 'this' parameter to avoid calling
       // getInterceptor again, so the receiver must be the interceptor (likely
       // `this`), not `null`.
@@ skipping 11 matching lines @@
         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;
   }
 }