Remove =List in JS, use JSExtendableArray instead.

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:collection' show Queue;
 import 'dart2jslib.dart' hide SourceString;
 import 'dart_types.dart';
 import 'elements/elements.dart';
 import 'js_backend/js_backend.dart';
 import 'resolution/resolution.dart' show ResolverVisitor;
 import 'scanner/scannerlib.dart';
 import 'ssa/ssa.dart';
 import 'tree/tree.dart';
 import 'universe/universe.dart' show SideEffects;
 import 'util/util.dart';
 import 'js/js.dart' as js;
 
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
 
   /// The type Object, but no subtypes:
   static const JsObject = const SpecialType._('=Object');
-
-  /// The specific implementation of List that is JavaScript Array:
-  static const JsArray = const SpecialType._('=List');
 }
 
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
   /// Initial entry point to native enqueuer.
   void processNativeClasses(Iterable<LibraryElement> libraries) {}
 
@@ skipping 283 matching lines @@
   NativeBehavior getNativeBehaviorOf(Send node) => nativeBehaviors[node];
 
   processNativeBehavior(NativeBehavior behavior, cause) {
     // TODO(ahe): Is this really a global dependency?
     TreeElements elements = compiler.globalDependencies;
     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) {
-          world.registerInstantiatedClass(compiler.listClass, elements);
-        } else if (type == SpecialType.JsObject) {
+        if (type == SpecialType.JsObject) {
           world.registerInstantiatedClass(compiler.objectClass, elements);
         }
         continue;
       }
       if (type is InterfaceType) {
         if (type.element == compiler.intClass) {
           world.registerInstantiatedClass(compiler.intClass, elements);
         } else if (type.element == compiler.doubleClass) {
           world.registerInstantiatedClass(compiler.doubleClass, elements);
         } else if (type.element == compiler.numClass) {
           world.registerInstantiatedClass(compiler.doubleClass, elements);
           world.registerInstantiatedClass(compiler.intClass, elements);
         } else if (type.element == compiler.stringClass) {
           world.registerInstantiatedClass(compiler.stringClass, elements);
         } else if (type.element == compiler.nullClass) {
           world.registerInstantiatedClass(compiler.nullClass, elements);
         } else if (type.element == compiler.boolClass) {
           world.registerInstantiatedClass(compiler.boolClass, elements);
+        } else if (compiler.types.isSubtype(
+                      type, compiler.backend.listImplementation.rawType)) {
+          world.registerInstantiatedClass(type.element, elements);
         }
       }
       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
@@ skipping 262 matching lines @@
   final SideEffects sideEffects = new SideEffects.empty();
 
   static NativeBehavior NONE = new NativeBehavior();
 
   static NativeBehavior ofJsCall(Send jsCall, Compiler compiler, resolver) {
     // The first argument of a JS-call is a string encoding various attributes
     // of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
-    //  '=List'.        A JavaScript Array, no subtype.
 
     var argNodes = jsCall.arguments;
     if (argNodes.isEmpty) {
       compiler.cancel("JS expression has no type", node: jsCall);
     }
 
     var code = argNodes.tail.head;
     if (code is !StringNode || code.isInterpolation) {
       compiler.cancel('JS code must be a string literal', node: code);
     }
@@ skipping 161 matching lines @@
         _escape(parameters.head, compiler);
       }
     } else {
       typesInstantiated.add(type);
     }
   }
 
   static _parseType(String typeString, Compiler compiler,
       lookup(name), locationNodeOrElement) {
     if (typeString == '=Object') return SpecialType.JsObject;
-    if (typeString == '=List') return SpecialType.JsArray;
     if (typeString == 'dynamic') {
       return  compiler.dynamicClass.computeType(compiler);
     }
     DartType type = lookup(typeString);
     if (type != null) return type;
 
     int index = typeString.indexOf('<');
     if (index < 1) {
       compiler.cancel("Type '$typeString' not found",
           node: _errorNode(locationNodeOrElement, compiler));
@@ skipping 188 matching lines @@
           'native "..." syntax is restricted to functions with zero parameters',
           node: nativeBody);
     }
     LiteralString jsCode = nativeBody.asLiteralString();
     builder.push(new HForeign.statement(
         new js.LiteralStatement(jsCode.dartString.slowToString()),
         <HInstruction>[],
         new SideEffects()));
   }
 }