Remove Collection, Collections and clean up List/Set/Queue implementations of retain/remove.

sdk/lib/_internal/compiler/implementation/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 518 matching lines @@
         name = element.name.slowToString();
       }
     } else if (element.isLibrary()) {
       name = LIBRARY_PREFIX;
     } else {
       name = element.name.slowToString();
     }
     return name;
   }
 
-  String getInterceptorSuffix(Collection<ClassElement> classes) {
+  String getInterceptorSuffix(Iterable<ClassElement> classes) {
     String abbreviate(ClassElement cls) {
       if (cls == compiler.objectClass) return "o";
       JavaScriptBackend backend = compiler.backend;
       if (cls == backend.jsStringClass) return "s";
       if (cls == backend.jsArrayClass) return "a";
       if (cls == backend.jsDoubleClass) return "d";
       if (cls == backend.jsIntClass) return "i";
       if (cls == backend.jsNumberClass) return "n";
       if (cls == backend.jsNullClass) return "u";
       if (cls == backend.jsFunctionClass) return "f";
       if (cls == backend.jsBoolClass) return "b";
       if (cls == backend.jsInterceptorClass) return "I";
       return cls.name.slowToString();
     }
     List<String> names = classes
         .where((cls) => !cls.isNative())
         .map(abbreviate)
         .toList();
     // There is one dispatch mechanism for all native classes.
     if (classes.any((cls) => cls.isNative())) {
       names.add("x");
     }
     // Sort the names of the classes after abbreviating them to ensure
     // the suffix is stable and predictable for the suggested names.
     names.sort();
     return names.join();
   }
 
-  String getInterceptorName(Element element, Collection<ClassElement> classes) {
+  String getInterceptorName(Element element, Iterable<ClassElement> classes) {
     JavaScriptBackend backend = compiler.backend;
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes, we
       // need to go through the generic getInterceptorMethod, since any subclass
       // of the base Interceptor could match.
       return getName(element);
     }
     String suffix = getInterceptorSuffix(classes);
     return getMappedGlobalName("${element.name.slowToString()}\$$suffix");
   }
 
   String getOneShotInterceptorName(Selector selector,
-                                   Collection<ClassElement> classes) {
+                                   Iterable<ClassElement> classes) {
     JavaScriptBackend backend = compiler.backend;
     // The one-shot name is a global name derived from the invocation name.  To
     // avoid instability we would like the names to be unique and not clash with
     // other global names.
 
     String root = invocationName(selector);  // Is already safe.
 
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes,
       // this is the most general specialization which uses the generic
@@ skipping 533 matching lines @@
     hash = hash ^ (hash >> 6);
     return hash;
   }
 
   static int _finish(int hash) {
     hash = _MASK & (hash + (((_MASK >> 3) & hash) <<  3));
     hash = hash & (hash >> 11);
     return _MASK & (hash + (((_MASK >> 15) & hash) << 15));
   }
 }