Revert "dart2js cps: 'is' checks on types with type arguments."

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();
 
-  /// Creates a type test or type cast of [value] against [type].
-  ir.Primitive buildTypeOperator(ir.Primitive value,
-                                 DartType type,
-                                 {bool isTypeTest});
+  /// 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.
   ///
@@ skipping 1312 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 26 matching lines @@
         clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
                                            initialValue: traceParameter);
       }
       clause.buildCatchBlock(clauseBuilder);
       if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = clauseBuilder._root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
       elseContinuation.body = catchBody;
 
-      // Build the type test guarding this clause. We can share the environment
-      // with the nested builder because this part cannot mutate it.
-      IrBuilder checkBuilder = catchBuilder.makeDelimitedBuilder(environment);
-      ir.Primitive typeMatches =
-          checkBuilder.buildTypeOperator(exceptionParameter,
-                                         clause.type,
-                                         isTypeTest: true);
-      checkBuilder.add(new ir.LetCont.many([thenContinuation, elseContinuation],
-                           new ir.Branch(new ir.IsTrue(typeMatches),
-                                         thenContinuation,
-                                         elseContinuation)));
-      catchBody = checkBuilder._root;
+      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(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 128 matching lines @@
 
     add(new ir.LetCont(joinContinuation,
           new ir.LetCont.many(<ir.Continuation>[thenContinuation,
                                                 elseContinuation],
               new ir.Branch(new ir.IsTrue(condition),
                             thenContinuation,
                             elseContinuation))));
     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});
+
   /// 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).
     // The translation must convert both e0 and e1 to booleans and handle
@@ skipping 248 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 value,
+  ir.Primitive buildTypeOperator(ir.Primitive receiver,
                                  DartType type,
-                                 {bool isTypeTest}) {
+                                 {bool isTypeTest: false,
+                                  bool isNotCheck: false}) {
     assert(isOpen);
     assert(isTypeTest != null);
+    assert(!isNotCheck || isTypeTest);
     ir.Primitive check = _continueWithExpression(
-            (k) => new ir.TypeOperator(value, type,
-                       const <ir.Primitive>[], k, isTypeTest: isTypeTest));
-    return check;
+            (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 216 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 54 matching lines @@
   ir.Primitive buildTypeExpression(DartType type) {
     if (type is TypeVariableType) {
       return buildTypeVariableAccess(type);
     } else if (type is InterfaceType) {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       type.forEachTypeVariable((TypeVariableType variable) {
         ir.Primitive value = buildTypeVariableAccess(variable);
         arguments.add(value);
       });
       return addPrimitive(new ir.TypeExpression(type, arguments));
-    } else if (type is DynamicType) {
-      return buildNullConstant();
     } else {
       // TypedefType can reach here, and possibly other things.
       throw 'unimplemented translation of type expression $type';
     }
   }
 
   /// Obtains the internal type representation of the type held in [variable].
   ///
   /// The value of [variable] is taken from the current receiver object, or
   /// if we are currently building a constructor field initializer, from the
@@ skipping 24 matching lines @@
     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 value,
+  ir.Primitive buildTypeOperator(ir.Primitive receiver,
                                  DartType type,
-                                 {bool isTypeTest}) {
+                                 {bool isTypeTest: false,
+                                  bool isNotCheck: false}) {
     assert(isOpen);
     assert(isTypeTest != null);
-    if (isTypeTest) {
-      // The TypeOperator node does not allow the Object, dynamic, and Null types,
-      // because the null value satisfies them. These must be handled here.
-      if (type.isObject || type.isDynamic) {
-        // `x is Object` and `x is dynamic` are always true, even if x is null.
-        return buildBooleanConstant(true);
-      }
-      if (type is InterfaceType && type.element == program.nullClass) {
-        // `x is Null` is true if and only if x is null.
-        return addPrimitive(new ir.Identical(value, buildNullConstant()));
-      }
-    }
-    // Null cannot not satisfy the check. Use a standard subtype check.
-    List<ir.Primitive> typeArguments = const <ir.Primitive>[];
-    if (type is GenericType && type.typeArguments.isNotEmpty) {
-      typeArguments = type.typeArguments.map(buildTypeExpression).toList();
-    }
+    assert(!isNotCheck || isTypeTest);
+    ir.Primitive interceptor =
+        addPrimitive(new ir.Interceptor(receiver, program.interceptedClasses));
     ir.Primitive check = _continueWithExpression(
-            (k) => new ir.TypeOperator(value,
-                       type, typeArguments, k, isTypeTest: isTypeTest));
-    return check;
+            (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;
 }