Move the handling of operator[] into the new interceptors.

sdk/lib/_internal/compiler/implementation/native_handler.dart

Index: sdk/lib/_internal/compiler/implementation/native_handler.dart
===================================================================
--- sdk/lib/_internal/compiler/implementation/native_handler.dart	(revision 16030)
+++ sdk/lib/_internal/compiler/implementation/native_handler.dart	(working copy)
@@ -104,6 +104,11 @@
 
   void processNativeClasses(Collection<LibraryElement> libraries) {
     libraries.forEach(processNativeClassesInLibrary);
+    processNativeClass(compiler.listClass);
+    processNativeClass(compiler.stringClass);
+    processNativeClass(compiler.intClass);
+    processNativeClass(compiler.doubleClass);
+    processNativeClass(compiler.nullClass);
     if (!enableLiveTypeAnalysis) {
       nativeClasses.forEach((c) => enqueueClass(c, 'forced'));
       flushQueue();
@@ -113,19 +118,19 @@
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
-      if (element.kind == ElementKind.CLASS) {
-        ClassElement classElement = element;
-        if (classElement.isNative()) {
-          nativeClasses.add(classElement);
-          unusedClasses.add(classElement);
-
-          // Resolve class to ensure the class has valid inheritance info.
-          classElement.ensureResolved(compiler);
-        }
+      if (element.isClass() && element.isNative()) {
+        processNativeClass(element);
       }
     });
   }
 
+  void processNativeClass(ClassElement classElement) {
+    nativeClasses.add(classElement);
+    unusedClasses.add(classElement);
+    // Resolve class to ensure the class has valid inheritance info.
+    classElement.ensureResolved(compiler);
+  }
+
   ClassElement get annotationCreatesClass {
     findAnnotationClasses();
     return _annotationCreatesClass;
@@ -311,27 +316,12 @@
       matchedTypeConstraints.add(type);
       if (type is SpecialType) {
         if (type == SpecialType.JsArray) {
-          world.registerInstantiatedClass(compiler.listClass);
+          enqueueClass(compiler.listClass, 'core type');
         } else if (type == SpecialType.JsObject) {
-          world.registerInstantiatedClass(compiler.objectClass);
+          enqueueClass(compiler.objectClass, 'core type');
         }
         continue;
       }
-      if (type is InterfaceType) {
-        if (type.element == compiler.intClass) {
-          world.registerInstantiatedClass(compiler.intClass);
-        } else if (type.element == compiler.doubleClass) {
-          world.registerInstantiatedClass(compiler.doubleClass);
-        } else if (type.element == compiler.numClass) {
-          world.registerInstantiatedClass(compiler.numClass);
-        } else if (type.element == compiler.stringClass) {
-          world.registerInstantiatedClass(compiler.stringClass);
-        } else if (type.element == compiler.nullClass) {
-          world.registerInstantiatedClass(compiler.nullClass);
-        } else if (type.element == compiler.boolClass) {
-          world.registerInstantiatedClass(compiler.boolClass);
-        }
-      }
       assert(type is DartType);
       enqueueUnusedClassesMatching(
           (nativeClass) => compiler.types.isSubtype(nativeClass.thisType, type),