Revert r16032: it revealed a bug in our bailout environment computation.

sdk/lib/_internal/compiler/implementation/native_handler.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.
 
 library native;
 
 import 'dart:uri';
 import 'dart2jslib.dart' hide SourceString;
 import 'elements/elements.dart';
 import 'js_backend/js_backend.dart';
@@ skipping 86 matching lines @@
 
   ClassElement _annotationCreatesClass;
   ClassElement _annotationReturnsClass;
   ClassElement _annotationJsNameClass;
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(this.world, this.compiler, this.enableLiveTypeAnalysis);
 
   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();
     }
   }
 
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
-      if (element.isClass() && element.isNative()) {
-        processNativeClass(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);
+        }
       }
     });
   }
 
-  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;
   }
 
   ClassElement get annotationReturnsClass {
     findAnnotationClasses();
     return _annotationReturnsClass;
   }
 
@@ skipping 165 matching lines @@
     flushQueue();
   }
 
   processNativeBehavior(NativeBehavior behavior, cause) {
     bool allUsedBefore = unusedClasses.isEmpty;
     for (var type in behavior.typesInstantiated) {
       if (matchedTypeConstraints.contains(type)) continue;
       matchedTypeConstraints.add(type);
       if (type is SpecialType) {
         if (type == SpecialType.JsArray) {
-          enqueueClass(compiler.listClass, 'core type');
+          world.registerInstantiatedClass(compiler.listClass);
         } else if (type == SpecialType.JsObject) {
-          enqueueClass(compiler.objectClass, 'core type');
+          world.registerInstantiatedClass(compiler.objectClass);
         }
         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),
           cause,
           'subtypeof($type)');
     }
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
     if (unusedClasses.isEmpty && !allUsedBefore) {
@@ skipping 543 matching lines @@
         builder.add(new HForeign(
             new DartString.literal('${parameter.name.slowToString()} = #'),
             const LiteralDartString('void'),
             <HInstruction>[jsClosure]));
       }
     });
     LiteralString jsCode = nativeBody.asLiteralString();
     builder.push(new HForeign.statement(jsCode.dartString, <HInstruction>[]));
   }
 }