Fix code-size regression

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/registry.dart' show Registry;
 import '../common/resolution.dart' show Resolution;
@@ skipping 502 matching lines @@
         } else if (type == coreTypes.stringType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.nullType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.boolType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (compiler.types
             .isSubtype(type, backend.listImplementation.rawType)) {
           backend.registerInstantiatedType(type, world, registry);
         }
+        // TODO(johnniwinther): Improve spec string precision to handle type
+        // arguments and implements relations that preserve generics. Currently
+        // we cannot distinguish between `List`, `List<dynamic>`, and
+        // `List<int>` and take all to mean `List<E>`; in effect not including
+        // any native subclasses of generic classes.

[sra1, 2016/05/31 20:47:05]

Add comment that we should hunt down uses of `List` in spec strings and replace
with the correct implementation types, (likely JSArray, but possibly a union).

[Johnni Winther, 2016/06/02 08:19:20]

Done.

+        enqueueUnusedClassesMatching((ClassElement nativeClass) {
+          InterfaceType nativeType = nativeClass.thisType;
+          InterfaceType specType = type.element.thisType;
+          return compiler.types.isSubtype(nativeType, specType);
+        }, cause, 'subtypeof($type)');
+        return;
       }
-      assert(type is DartType);
-      enqueueUnusedClassesMatching(
-          (nativeClass) => compiler.types.isSubtype(nativeClass.thisType, type),
-          cause,
-          'subtypeof($type)');
+      assert(type is VoidType || type is DynamicType);
     }
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
     if (unusedClasses.isEmpty && !allUsedBefore) {
       reporter.log('All native types marked as used due to $cause.');
     }
   }
 
   enqueueUnusedClassesMatching(bool predicate(classElement), cause,
@@ skipping 156 matching lines @@
     List<Element> directSubtypes =
         emitter.directSubtypes.putIfAbsent(superclass, () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }