dart2js: remove (broken) support for nsm on native classes.

pkg/compiler/lib/src/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 const USE_NEW_EMITTER = const bool.fromEnvironment("dart2js.use.new.emitter");
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
@@ skipping 265 matching lines @@
     // 1. We need to generate all classes that are instantiated.
     addClassesWithSuperclasses(instantiatedClasses);
 
     // 2. Add all classes used as mixins.
     Set<ClassElement> mixinClasses = neededClasses
         .where((ClassElement element) => element.isMixinApplication)
         .map(computeMixinClass)
         .toSet();
     neededClasses.addAll(mixinClasses);
 
-    // 3. If we need noSuchMethod support, we run through all needed
-    // classes to figure out if we need the support on any native
-    // class. If so, we let the native emitter deal with it.
-    if (compiler.enabledNoSuchMethod) {
-      String noSuchMethodName = Compiler.NO_SUCH_METHOD;
-      Selector noSuchMethodSelector = compiler.noSuchMethodSelector;
-      for (ClassElement element in neededClasses) {
-        if (!element.isNative) continue;
-        Element member = element.lookupLocalMember(noSuchMethodName);
-        if (member == null) continue;
-        if (noSuchMethodSelector.applies(member, compiler.world)) {
-          nativeEmitter.handleNoSuchMethod = true;
-          break;
-        }
-      }
-    }
-
-    // 4. Find all classes needed for rti.
+    // 3. Find all classes needed for rti.
     // It is important that this is the penultimate step, at this point,
     // neededClasses must only contain classes that have been resolved and
     // codegen'd. The rtiNeededClasses may contain additional classes, but
     // these are thought to not have been instantiated, so we neeed to be able
     // to identify them later and make sure we only emit "empty shells" without
     // fields, etc.
     typeTestRegistry.computeRtiNeededClasses();
 
     // TODO(floitsch): either change the name, or get the rti-classes
     // differently.
@@ skipping 14 matching lines @@
     if (neededClasses.contains(backend.jsStringClass)) {
       neededClasses.add(compiler.stringClass);
     }
     if (neededClasses.contains(backend.jsBoolClass)) {
       neededClasses.add(compiler.boolClass);
     }
     if (neededClasses.contains(backend.jsArrayClass)) {
       neededClasses.add(compiler.listClass);
     }
 
-    // 5. Finally, sort the classes.
+    // 4. Finally, sort the classes.
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     for (ClassElement element in sortedClasses) {
       if (Elements.isNativeOrExtendsNative(element) &&
           !typeTestRegistry.rtiNeededClasses.contains(element)) {
         // For now, native classes and related classes cannot be deferred.
         nativeClassesAndSubclasses.add(element);
         assert(invariant(element,
                          !compiler.deferredLoadTask.isDeferred(element)));
         outputClassLists.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
@@ skipping 110 matching lines @@
   jsAst.Expression typeAccess(Element e);
 
   /// Returns the JS expression representing a function that returns 'null'
   jsAst.Expression generateFunctionThatReturnsNull();
 
   int compareConstants(ConstantValue a, ConstantValue b);
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant);
 
   void invalidateCaches();
 }