Extract interceptor calls from raw is-checks.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 250 matching lines @@
    * always specializing it based on the incoming type. The keys in
    * the map are the names of these specialized versions. Note that
    * the generic version that contains all possible type checks is
    * also stored in this map.
    */
   final Map<String, Set<ClassElement>> specializedGetInterceptors;
 
   /**
    * Set of classes whose methods are intercepted.
    */
-  final Set<ClassElement> interceptedClasses = new Set<ClassElement>();
+  final Set<ClassElement> _interceptedClasses = new Set<ClassElement>();
 
   /**
    * Set of classes used as mixins on native classes.  Methods on these classes
    * might also be mixed in to non-native classes.
    */
   final Set<ClassElement> classesMixedIntoNativeClasses =
       new Set<ClassElement>();
 
   /**
    * Set of classes whose `operator ==` methods handle `null` themselves.
@@ skipping 268 matching lines @@
         jsArrayClass, const SourceString('add'));
 
     jsStringClass.ensureResolved(compiler);
     jsStringSplit = compiler.lookupElementIn(
         jsStringClass, const SourceString('split'));
     jsStringConcat = compiler.lookupElementIn(
         jsStringClass, const SourceString('concat'));
     jsStringToString = compiler.lookupElementIn(
         jsStringClass, const SourceString('toString'));
 
-    for (ClassElement cls in classes) {
-      if (cls != null) interceptedClasses.add(cls);
-    }
-
     typeLiteralClass = compiler.findHelper(const SourceString('TypeImpl'));
     mapLiteralClass =
         compiler.coreLibrary.find(const SourceString('LinkedHashMap'));
     constMapLiteralClass =
         compiler.findHelper(const SourceString('ConstantMap'));
 
     objectEquals = compiler.lookupElementIn(
         compiler.objectClass, const SourceString('=='));
 
     specialOperatorEqClasses
@@ skipping 49 matching lines @@
         }
       },
       includeSuperAndInjectedMembers: true);
     }
   }
 
   void addInterceptors(ClassElement cls,
                        Enqueuer enqueuer,
                        TreeElements elements) {
     if (enqueuer.isResolutionQueue) {
+      _interceptedClasses.add(jsInterceptorClass);
+      _interceptedClasses.add(cls);
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
           // All methods on [Object] are shadowed by [Interceptor].
           if (classElement == compiler.objectClass) return;
           Set<Element> set = interceptedElements.putIfAbsent(
               member.name, () => new Set<Element>());
           set.add(member);
         },
         includeSuperAndInjectedMembers: true);
     }
     enqueueClass(enqueuer, cls, elements);
   }
 
+  Set<ClassElement> get interceptedClasses {
+    assert(compiler.enqueuer.resolution.queueIsClosed);
+    return _interceptedClasses;
+  }
+
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     String name = namer.getInterceptorName(getInterceptorMethod, classes);
     if (classes.contains(jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
@@ skipping 48 matching lines @@
       }
     }
     ClassElement result = null;
     if (cls == compiler.stringClass || cls == jsStringClass) {
       addInterceptors(jsStringClass, enqueuer, elements);
     } else if (cls == compiler.listClass
                || cls == jsArrayClass
                || cls == jsFixedArrayClass
                || cls == jsExtendableArrayClass) {
       addInterceptors(jsArrayClass, enqueuer, elements);
-      enqueueClass(enqueuer, jsFixedArrayClass, elements);
-      enqueueClass(enqueuer, jsExtendableArrayClass, elements);
+      addInterceptors(jsMutableArrayClass, enqueuer, elements);
+      addInterceptors(jsFixedArrayClass, enqueuer, elements);
+      addInterceptors(jsExtendableArrayClass, enqueuer, elements);
     } else if (cls == compiler.intClass || cls == jsIntClass) {
       addInterceptors(jsIntClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls == compiler.doubleClass || cls == jsDoubleClass) {
       addInterceptors(jsDoubleClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls == compiler.boolClass || cls == jsBoolClass) {
       addInterceptors(jsBoolClass, enqueuer, elements);
     } else if (cls == compiler.nullClass || cls == jsNullClass) {
       addInterceptors(jsNullClass, enqueuer, elements);
@@ skipping 551 matching lines @@
                 ? const PropertyCheckedModeHelper(
                     const SourceString('propertyTypeCast'))
                 : const PropertyCheckedModeHelper(
                     const SourceString('propertyTypeCheck'));
           }
         }
       }
     }
   }
 
+  /**
+   * Returns [:true:] if the checking of [type] is performed directly on the
+   * object and not on an interceptor.
+   */
+  bool hasDirectCheckFor(DartType type) {
+    Element element = type.element;
+    return element == compiler.stringClass ||
+        element == compiler.boolClass ||
+        element == compiler.numClass ||
+        element == compiler.intClass ||
+        element == compiler.doubleClass ||
+        element == jsArrayClass ||
+        element == jsMutableArrayClass ||
+        element == jsExtendableArrayClass ||
+        element == jsFixedArrayClass;
+  }
+
   Element getExceptionUnwrapper() {
     return compiler.findHelper(const SourceString('unwrapException'));
   }
 
   Element getThrowRuntimeError() {
     return compiler.findHelper(const SourceString('throwRuntimeError'));
   }
 
   Element getThrowAbstractClassInstantiationError() {
     return compiler.findHelper(
@@ skipping 324 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }