Rename mappedBy to map.

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.mappedBy((param) => param.name));
+        stubParameters.map((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.mappedBy((param) => js.use(param.name))))));
+                    parameters.map((param) => js.use(param.name))))));
   }
 
   js.Block generateMethodBodyWithPrototypeCheckForElement(
       FunctionElement element,
       js.Block body,
       List<js.Parameter> parameters) {
     ElementKind kind = element.kind;
     if (kind != ElementKind.FUNCTION &&
         kind != ElementKind.GETTER &&
         kind != ElementKind.SETTER) {
@@ skipping 130 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.mappedBy((cls) =>
+              preorderDispatchClasses.map((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 117 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');
   }
 }