Revert "Extract interceptor calls from raw is-checks."

sdk/lib/_internal/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2198 matching lines @@
 
     List<js.Expression> arguments = <js.Expression>[object, record];
     FunctionElement helper =
         compiler.findHelper(const SourceString('isJsIndexable'));
     world.registerStaticUse(helper);
     String helperName = backend.namer.isolateAccess(helper);
     push(new js.Call(new js.VariableUse(helperName), arguments));
     if (negative) push(new js.Prefix('!', pop()));
   }
 
-  void checkType(HInstruction input, HInstruction interceptor,
-                 DartType type, {bool negative: false}) {
+  void checkType(HInstruction input, DartType type, {bool negative: false}) {
     Element element = type.element;
     if (element == backend.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
     } else if (element == backend.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
         checkMutableArray(input);
       }
       return;
     } else if (element == backend.jsExtendableArrayClass) {
       if (negative) {
         checkFixedArray(input);
       } else {
         checkExtendableArray(input);
       }
       return;
     } else if (element == backend.jsFixedArrayClass) {
       if (negative) {
         checkExtendableArray(input);
       } else {
         checkFixedArray(input);
       }
       return;
     }
-    use(interceptor);
+    use(input);
 
+    // Hack in interceptor.  Ideally the interceptor would occur at the
+    // instruction level to allow optimizations, and checks would be broken into
+    // several smaller tests.
+    // This code is a slice of visitInterceptor for the univeral interceptor.
+    String interceptorName = backend.namer.getInterceptorName(
+        backend.getInterceptorMethod, backend.interceptedClasses);
+    backend.registerSpecializedGetInterceptor(backend.interceptedClasses);
+    backend.registerUseInterceptor(world);
+
+    var isolate = new js.VariableUse(backend.namer.CURRENT_ISOLATE);
+    List<js.Expression> arguments = <js.Expression>[pop()];
+    push(jsPropertyCall(isolate, interceptorName, arguments));
     world.registerIsCheck(type, work.resolutionTree);
 
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), backend.namer.operatorIsType(type));
     // We always negate at least once so that the result is boolified.
     push(new js.Prefix('!', field));
     // If the result is not negated, put another '!' in front.
     if (!negative) push(new js.Prefix('!', pop()));
   }
 
   void handleNumberOrStringSupertypeCheck(HInstruction input,
-                                          HInstruction interceptor,
                                           DartType type,
                                           { bool negative: false }) {
     assert(!identical(type.element, compiler.listClass)
            && !Elements.isListSupertype(type.element, compiler)
            && !Elements.isStringOnlySupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
     checkNum(input, relation);
     js.Expression numberTest = pop();
     checkString(input, relation);
     js.Expression stringTest = pop();
     checkObject(input, relation);
     js.Expression objectTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, type, negative: negative);
     String combiner = negative ? '&&' : '||';
     String combiner2 = negative ? '||' : '&&';
     push(new js.Binary(combiner,
                        new js.Binary(combiner, numberTest, stringTest),
                        new js.Binary(combiner2, objectTest, pop())));
   }
 
   void handleStringSupertypeCheck(HInstruction input,
-                                  HInstruction interceptor,
                                   DartType type,
                                   { bool negative: false }) {
     assert(!identical(type.element, compiler.listClass)
            && !Elements.isListSupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
     checkString(input, relation);
     js.Expression stringTest = pop();
     checkObject(input, relation);
     js.Expression objectTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, type, negative: negative);
     String combiner = negative ? '||' : '&&';
     push(new js.Binary(negative ? '&&' : '||',
                        stringTest,
                        new js.Binary(combiner, objectTest, pop())));
   }
 
   void handleListOrSupertypeCheck(HInstruction input,
-                                  HInstruction interceptor,
                                   DartType type,
                                   { bool negative: false }) {
     assert(!identical(type.element, compiler.stringClass)
            && !Elements.isStringOnlySupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
     checkObject(input, relation);
     js.Expression objectTest = pop();
     checkArray(input, relation);
     js.Expression arrayTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, type, negative: negative);
     String combiner = negative ? '&&' : '||';
     push(new js.Binary(negative ? '||' : '&&',
                        objectTest,
                        new js.Binary(combiner, arrayTest, pop())));
   }
 
   void visitIs(HIs node) {
     emitIs(node, "===");
   }
 
   void emitIs(HIs node, String relation)  {
     DartType type = node.typeExpression;
     world.registerIsCheck(type, work.resolutionTree);
     HInstruction input = node.expression;
 
     // If this is changed to single == there are several places below that must
     // be changed to match.
     assert(relation == '===' || relation == '!==');
     bool negative = relation == '!==';
 
     if (node.isVariableCheck || node.isCompoundCheck) {
       use(node.checkCall);
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       assert(node.isRawCheck);
-      HInstruction interceptor = node.interceptor;
       LibraryElement coreLibrary = compiler.coreLibrary;
       ClassElement objectClass = compiler.objectClass;
       Element element = type.element;
       if (element == compiler.nullClass) {
         if (negative) {
           checkNonNull(input);
         } else {
           checkNull(input);
         }
       } else if (identical(element, objectClass) || type.treatAsDynamic) {
@@ skipping 14 matching lines @@
         attachLocationToLast(node);
       } else if (element == compiler.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
         checkNum(input, relation);
         js.Expression numTest = pop();
         checkBigInt(input, relation);
         push(new js.Binary(negative ? '||' : '&&', numTest, pop()), node);
       } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
-        handleNumberOrStringSupertypeCheck(
-            input, interceptor, type, negative: negative);
+        handleNumberOrStringSupertypeCheck(input, type, negative: negative);
         attachLocationToLast(node);
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
-        handleStringSupertypeCheck(
-            input, interceptor, type, negative: negative);
+        handleStringSupertypeCheck(input, type, negative: negative);
         attachLocationToLast(node);
       } else if (identical(element, compiler.listClass)
                  || Elements.isListSupertype(element, compiler)) {
-        handleListOrSupertypeCheck(
-            input, interceptor, type, negative: negative);
+        handleListOrSupertypeCheck(input, type, negative: negative);
         attachLocationToLast(node);
-      } else if (type.kind == TypeKind.FUNCTION) {
-        checkType(input, interceptor, type, negative: negative);
+      } else if (element.isTypedef()) {
+        if (negative) {
+          checkNull(input);
+        } else {
+          checkNonNull(input);
+        }
+        js.Expression nullTest = pop();
+        checkType(input, type, negative: negative);
+        push(new js.Binary(negative ? '||' : '&&', nullTest, pop()));
         attachLocationToLast(node);
       } else if ((input.canBePrimitive(compiler)
                   && !input.canBePrimitiveArray(compiler))
                  || input.canBeNull()) {
         checkObject(input, relation);
         js.Expression objectTest = pop();
-        checkType(input, interceptor, type, negative: negative);
+        checkType(input, type, negative: negative);
         push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node);
       } else {
-        checkType(input, interceptor, type, negative: negative);
+        checkType(input, type, negative: negative);
         attachLocationToLast(node);
       }
     }
+    if (node.nullOk) {
+      if (negative) {
+        checkNonNull(input);
+        push(new js.Binary('&&', pop(), pop()), node);
+      } else {
+        checkNull(input);
+        push(new js.Binary('||', pop(), pop()), node);
+      }
+    }
   }
 
   js.Expression generateTest(HCheck node) {
     HInstruction input = node.checkedInput;
     TypeMask receiver = input.instructionType.computeMask(compiler);
     TypeMask mask = node.instructionType.computeMask(compiler);
     bool turnIntoNullCheck = mask.nullable() == receiver;
     js.Expression test;
     if (turnIntoNullCheck) {
       use(input);
@@ skipping 559 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }