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

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

 // Copyright (c) 2013, 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.ir_builder;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 448 matching lines @@
 
   /// Reifies the value of [variable] on the current receiver object.
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable);
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
+  /// In JS-mode, gets an interceptor for [value].
+  /// In Dart-mode, simply returns [value].
+  ir.Primitive buildGetInterceptor(ir.Primitive value);
+
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
   IrBuilderSharedState state;
 
   /// A map from variable indexes to their values.
   ///
   /// [BoxLocal]s map to their box. [LocalElement]s that are boxed are not
@@ skipping 1311 matching lines @@
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     // Handlers are always translated as having both exception and stack trace
     // parameters.  Multiple clauses do not have to use the same names for
     // them.  Choose the first of each as the name hint for the respective
     // handler parameter.
     ir.Parameter exceptionParameter =
         new ir.Parameter(catchClauseInfos.first.exceptionVariable);
+    ir.Primitive exceptionInterceptor = new ir.Parameter(null);
     LocalVariableElement traceVariable;
     CatchClauseInfo catchAll;
     for (int i = 0; i < catchClauseInfos.length; ++i) {
       CatchClauseInfo info = catchClauseInfos[i];
       if (info.type == null) {
         catchAll = info;
         catchClauseInfos.length = i;
         break;
       }
       if (traceVariable == null) {
@@ skipping 35 matching lines @@
 
       ir.Parameter typeMatches = new ir.Parameter(null);
       ir.Continuation checkType = new ir.Continuation([typeMatches]);
       checkType.body =
           new ir.LetCont.many([thenContinuation, elseContinuation],
               new ir.Branch(new ir.IsTrue(typeMatches),
                             thenContinuation,
                             elseContinuation));
       catchBody =
           new ir.LetCont(checkType,
-              new ir.TypeOperator(exceptionParameter, clause.type, checkType,
+              new ir.TypeOperator(exceptionInterceptor, clause.type, checkType,
                                   isTypeTest: true));
     }
 
     List<ir.Parameter> catchParameters =
         <ir.Parameter>[exceptionParameter, traceParameter];
     ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
+    catchBuilder.buildGetInterceptor(exceptionParameter)
+                .substituteFor(exceptionInterceptor);
     catchBuilder.add(catchBody);
     catchContinuation.body = catchBuilder._root;
 
     tryCatchBuilder.add(
         new ir.LetHandler(catchContinuation, tryBuilder._root));
     add(new ir.LetCont(join.continuation, tryCatchBuilder._root));
     environment = join.environment;
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
@@ skipping 135 matching lines @@
     return resultParameter;
   }
 
   /// Creates a type test or type cast of [receiver] against [type].
   ///
   /// Set [isTypeTest] to `true` to create a type test and furthermore set
   /// [isNotCheck] to `true` to create a negated type test.
   ir.Primitive buildTypeOperator(ir.Primitive receiver,
                                  DartType type,
                                  {bool isTypeTest: false,
-                                  bool isNotCheck: false}) {
-    assert(isOpen);
-    assert(isTypeTest != null);
-    assert(!isNotCheck || isTypeTest);
-    ir.Primitive check = _continueWithExpression(
-        (k) => new ir.TypeOperator(receiver, type, k, isTypeTest: isTypeTest));
-    return isNotCheck ? buildNegation(check) : check;
-  }
+                                  bool isNotCheck: false});
 
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
       {bool isLazyOr: false}) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
@@ skipping 249 matching lines @@
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   ir.Primitive buildThis() {
     return state.enclosingMethodThisParameter;
   }
 
+  ir.Primitive buildGetInterceptor(ir.Primitive value) => value;
+
   @override
   ir.Primitive buildConstructorInvocation(ConstructorElement element,
                                           CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
     Selector selector =
         new Selector(SelectorKind.CALL, element.memberName, callStructure);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector,
             arguments, k));
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable) {
     return addPrimitive(new ir.ReifyTypeVar(variable.element));
   }
+
+  @override
+  ir.Primitive buildTypeOperator(ir.Primitive receiver,
+                                 DartType type,
+                                 {bool isTypeTest: false,
+                                  bool isNotCheck: false}) {
+    assert(isOpen);
+    assert(isTypeTest != null);
+    assert(!isNotCheck || isTypeTest);
+    ir.Primitive check = _continueWithExpression(
+            (k) => new ir.TypeOperator(receiver, type, k, isTypeTest: isTypeTest));
+    return isNotCheck ? buildNegation(check) : check;
+  }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
@@ skipping 215 matching lines @@
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
+  ir.Primitive buildGetInterceptor(ir.Primitive value) {
+    return addPrimitive(new ir.Interceptor(value, program.interceptedClasses));
+  }
+
   @override
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   @override
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
     add(new ir.SetField(buildThis(), target, value));
     return value;
   }
@@ skipping 96 matching lines @@
   @override
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable) {
     ir.Primitive typeArgument = buildTypeVariableAccess(variable);
     return addPrimitive(new ir.ReifyRuntimeType(typeArgument));
   }
 
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
+
+  @override
+  ir.Primitive buildTypeOperator(ir.Primitive receiver,
+                                 DartType type,
+                                 {bool isTypeTest: false,
+                                  bool isNotCheck: false}) {
+    assert(isOpen);
+    assert(isTypeTest != null);
+    assert(!isNotCheck || isTypeTest);
+    ir.Primitive interceptor =
+        addPrimitive(new ir.Interceptor(receiver, program.interceptedClasses));
+    ir.Primitive check = _continueWithExpression(
+            (k) => new ir.TypeOperator(interceptor, type, k,
+                                       isTypeTest: isTypeTest));
+    return isNotCheck ? buildNegation(check) : check;
+  }
+
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 61 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }