Big merge from experimental to bleeding edge.

sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.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 js_backend;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 143 matching lines @@
   }
 
   void potentiallyConvertDartClosuresToJs(List<js.Statement> statements,
                                           FunctionElement member,
                                           List<js.Parameter> stubParameters) {
     FunctionSignature parameters = member.computeSignature(compiler);
     Element converter =
         compiler.findHelper(const SourceString('convertDartClosureToJS'));
     String closureConverter = backend.namer.isolateAccess(converter);
     Set<String> stubParameterNames = new Set<String>.from(
-        stubParameters.map((param) => param.name));
+        stubParameters.mappedBy((param) => param.name));
     parameters.forEachParameter((Element parameter) {
       String name = parameter.name.slowToString();
       // If [name] is not in [stubParameters], then the parameter is an optional
       // parameter that was not provided for this stub.
       for (js.Parameter stubParameter in stubParameters) {
         if (stubParameter.name == name) {
           DartType type = parameter.computeType(compiler).unalias(compiler);
           if (type is FunctionType) {
             // The parameter type is a function type either directly or through
             // typedef(s).
@@ skipping 73 matching lines @@
       List<js.Parameter> parameters) {
     return js.if_(
         js.use('Object').dot('getPrototypeOf')
             .callWith([js.use('this')])
             .dot('hasOwnProperty').callWith([js.string(methodName)]),
         body,
         js.return_(
             js.use('Object').dot('prototype').dot(methodName).dot('call')
             .callWith(
                 <js.Expression>[js.use('this')]..addAll(
-                    parameters.map((param) => js.use(param.name))))));
+                    parameters.mappedBy((param) => js.use(param.name))))));
   }
 
   js.Block generateMethodBodyWithPrototypeCheckForElement(
       FunctionElement element,
       js.Block body,
       List<js.Parameter> parameters) {
     String methodName;
     Namer namer = backend.namer;
     if (element.kind == ElementKind.FUNCTION) {
       methodName = namer.instanceMethodName(element);
@@ skipping 22 matching lines @@
     Set<ClassElement> seen = new Set<ClassElement>();
     List<ClassElement> classes = <ClassElement>[];
     void visit(ClassElement cls) {
       if (seen.contains(cls)) return;
       seen.add(cls);
       getDirectSubclasses(cls).forEach(visit);
       classes.add(cls);
     }
     classesWithDynamicDispatch.forEach(visit);
 
-    Collection<ClassElement> preorderDispatchClasses = classes.filter(
+    List<ClassElement> preorderDispatchClasses = classes.where(
         (cls) => !getDirectSubclasses(cls).isEmpty &&
-                  classesWithDynamicDispatch.contains(cls));
+                  classesWithDynamicDispatch.contains(cls)).toList();
 
     if (!compiler.enableMinification) {
       nativeBuffer.add('// ${classes.length} classes\n');
     }
-    Collection<ClassElement> classesThatHaveSubclasses = classes.filter(
+    Iterable<ClassElement> classesThatHaveSubclasses = classes.where(
         (ClassElement t) => !getDirectSubclasses(t).isEmpty);
     if (!compiler.enableMinification) {
       nativeBuffer.add('// ${classesThatHaveSubclasses.length} !leaf\n');
     }
 
     // Generate code that builds the map from cls tags used in dynamic dispatch
     // to the set of cls tags of classes that extend (TODO: or implement) those
     // classes.  The set is represented as a string of tags joined with '|'.
     // This is easily split into an array of tags, or converted into a regexp.
     //
@@ skipping 85 matching lines @@
             new js.ExpressionStatement(
                 new js.VariableDeclarationList(initializations)));
       }
 
       // [table] is a list of lists, each inner list of the form:
       //   [dynamic-dispatch-tag, tags-of-classes-implementing-dispatch-tag]
       // E.g.
       //   [['Node', 'Text|HTMLElement|HTMLDivElement|...'], ...]
       js.Expression table =
           new js.ArrayInitializer.from(
-              preorderDispatchClasses.map((cls) =>
+              preorderDispatchClasses.mappedBy((cls) =>
                   new js.ArrayInitializer.from([
                       js.string(toNativeTag(cls)),
                       tagDefns[cls]])));
 
       //  $.dynamicSetMetadata(table);
       statements.add(
           new js.ExpressionStatement(
               new js.Call(
                   new js.VariableUse(dynamicSetMetadataName),
                   [table])));
@@ skipping 111 matching lines @@
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(js.prettyPrint(
           new js.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }