Big merge from experimental to bleeding edge.

sdk/lib/_internal/compiler/implementation/js_backend/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;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 466 matching lines @@
     // If the method is in an interceptor class, we need to also pass
     // the actual receiver.
     int extraArgumentCount = isInterceptorClass ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because [JsNames.getValid] used for getting parameter
     // names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
 
     // The parameters that this stub takes.
     List<js.Parameter> parametersBuffer =
-        new List<js.Parameter>(selector.argumentCount + extraArgumentCount);
+        new List<js.Parameter>.fixedLength(
+            selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<js.Expression> argumentsBuffer =
-        new List<js.Expression>(parameters.parameterCount + extraArgumentCount);
+        new List<js.Expression>.fixedLength(
+            parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptorClass) {
       count++;
       parametersBuffer[0] = new js.Parameter(receiverArgumentName);
       argumentsBuffer[0] = new js.VariableUse(receiverArgumentName);
     }
 
     int indexOfLastOptionalArgumentInParameters = positionalArgumentCount - 1;
     TreeElements elements =
@@ skipping 599 matching lines @@
               new js.Block(
                   <js.Statement>[
                       new js.Return(
                           new js.VariableUse('receiver')
                               .dot(name)
                               .callWith(arguments))]));
       builder.addProperty(name, function);
     }
   }
 
-  Collection<Element> getTypedefChecksOn(DartType type) {
-    return checkedTypedefs.filter((TypedefElement typedef) {
+  Iterable<Element> getTypedefChecksOn(DartType type) {
+    return checkedTypedefs.where((TypedefElement typedef) {
       FunctionType typedefType =
           typedef.computeType(compiler).unalias(compiler);
       return compiler.types.isSubtype(type, typedefType);
     });
   }
 
   /**
    * Generate "is tests" for [cls]: itself, and the "is tests" for the
    * classes it implements. We don't need to add the "is tests" of the
    * super class because they will be inherited at runtime.
@@ skipping 153 matching lines @@
     js.Expression assignment =
         js.assign(js.use(isolateProperties).dot(name), functionExpression);
     buffer.add(js.prettyPrint(assignment, compiler));
     buffer.add('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer buffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
-    Collection<Element> elements =
-        compiler.codegenWorld.generatedCode.keys.filter(isStaticFunction);
+    Iterable<Element> elements =
+        compiler.codegenWorld.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
-        new Set<Element>.from(
-            compiler.codegenWorld.generatedBailoutCode.keys.filter(
-                isStaticFunction));
+        compiler.codegenWorld.generatedBailoutCode.keys
+            .where(isStaticFunction)
+            .toSet();
 
     for (Element element in Elements.sortedByPosition(elements)) {
       js.Expression code = compiler.codegenWorld.generatedCode[element];
       emitStaticFunction(buffer, namer.getName(element), code);
       js.Expression bailoutCode =
           compiler.codegenWorld.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
@@ skipping 268 matching lines @@
                             buildGetter().dot(closureCallName)
                                 .callWith(arguments))]));
 
         defineStub(invocationName, function);
       }
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
-    List<VariableElement> staticNonFinalFields =
+    Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in staticNonFinalFields) {
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         js.Expression init =
             new js.Assignment(
                 new js.PropertyAccess.field(
                     new js.VariableUse(isolateProperties),
                     namer.getName(element)),
                 constantEmitter.referenceInInitializationContext(initialValue));
@@ skipping 135 matching lines @@
       // Values match JSInvocationMirror in js-helper library.
       int type = selector.invocationMirrorKind;
       String methodName = selector.invocationMirrorMemberName;
       List<js.Parameter> parameters = <js.Parameter>[];
       CodeBuffer args = new CodeBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         parameters.add(new js.Parameter('\$$i'));
       }
 
       List<js.Expression> argNames =
-          selector.getOrderedNamedArguments().map((SourceString name) =>
-              js.string(name.slowToString()));
+          selector.getOrderedNamedArguments().mappedBy((SourceString name) =>
+              js.string(name.slowToString())).toList();
 
       String internalName = namer.invocationMirrorInternalName(selector);
 
       String createInvocationMirror = namer.getName(
           compiler.createInvocationMirrorElement);
 
       js.Expression expression =
           new js.This()
           .dot(noSuchMethodName)
           .callWith(
               <js.Expression>[
                   new js.VariableUse(namer.CURRENT_ISOLATE)
                   .dot(createInvocationMirror)
                   .callWith(
                       <js.Expression>[
                           js.string(methodName),
                           js.string(internalName),
                           new js.LiteralNumber('$type'),
                           new js.ArrayInitializer.from(
-                              parameters.map((param) => js.use(param.name))),
+                              parameters.mappedBy((param) => js.use(param.name)).toList()),
                           new js.ArrayInitializer.from(argNames)])]);
       js.Expression function =
           new js.Fun(parameters,
               new js.Block(<js.Statement>[new js.Return(expression)]));
       return function;
     }
 
     void addNoSuchMethodHandlers(SourceString ignore, Set<Selector> selectors) {
       // Cache the object class and type.
       ClassElement objectClass = compiler.objectClass;
@@ skipping 313 matching lines @@
     if (backend.objectInterceptorClass == null) return;
     String objectName = namer.isolateAccess(backend.objectInterceptorClass);
     backend.specializedGetInterceptors.forEach(
         (String key, Collection<ClassElement> classes) {
           emitGetInterceptorMethod(buffer, objectName, key, classes);
         });
   }
 
   void computeNeededClasses() {
     instantiatedClasses =
-        compiler.codegenWorld.instantiatedClasses.filter(computeClassFilter());
-    neededClasses = new Set<ClassElement>.from(instantiatedClasses);
+        compiler.codegenWorld.instantiatedClasses.where(computeClassFilter());
+    neededClasses = instantiatedClasses.toSet();
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
   }
 
@@ skipping 78 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;