Stop passing library elements to tons of namer functions.

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 446 matching lines @@
     if (parameters.optionalParametersAreNamed
         && selector.namedArgumentCount == parameters.optionalParameterCount) {
       // If the selector has the same number of named arguments as
       // the element, we don't need to add a stub. The call site will
       // hit the method directly.
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
-    String invocationName =
-        namer.instanceMethodInvocationName(member.getLibrary(), member.name,
-                                           selector);
+    String invocationName = namer.invocationName(selector);
     if (alreadyGenerated.contains(invocationName)) return;
     alreadyGenerated.add(invocationName);
 
     JavaScriptBackend backend = compiler.backend;
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     // If the method is in an interceptor class, we need to also pass
     // the actual receiver.
     int extraArgumentCount = isInterceptorClass ? 1 : 0;
@@ skipping 599 matching lines @@
   void emitInterceptorMethods(ClassBuilder builder) {
     JavaScriptBackend backend = compiler.backend;
     // Emit forwarders for the ObjectInterceptor class. We need to
     // emit all possible sends on intercepted methods.
     for (Selector selector in backend.usedInterceptors) {
 
       List<js.Parameter> parameters = <js.Parameter>[];
       List<js.Expression> arguments = <js.Expression>[];
       parameters.add(new js.Parameter('receiver'));
 
-      String name;
-      if (selector.isGetter()) {
-        name = backend.namer.getterName(selector.library, selector.name);
-      } else if (selector.isSetter()) {
-        name = backend.namer.setterName(selector.library, selector.name);
+      String name = backend.namer.invocationName(selector);
+      if (selector.isSetter()) {
         parameters.add(new js.Parameter('value'));
         arguments.add(new js.VariableUse('value'));
       } else {
-        name = backend.namer.instanceMethodInvocationName(
-            selector.library, selector.name, selector);
         for (int i = 0; i < selector.argumentCount; i++) {
           String argName = 'a$i';
           parameters.add(new js.Parameter(argName));
           arguments.add(new js.VariableUse(argName));
         }
       }
       js.Fun function =
           new js.Fun(parameters,
               new js.Block(
                   <js.Statement>[
@@ skipping 373 matching lines @@
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
-    String getterName = namer.getterName(member.getLibrary(), member.name);
+    String getterName = namer.getterName(member);
     String targetName = namer.instanceMethodName(member);
 
     List<js.Parameter> parameters = <js.Parameter>[];
     List<js.Expression> arguments = <js.Expression>[];
     arguments.add(new js.This());
     arguments.add(js.string(targetName));
     if (inInterceptor) {
       parameters.add(new js.Parameter(extraArg));
       arguments.add(new js.VariableUse(extraArg));
     }
@@ skipping 23 matching lines @@
     JavaScriptBackend backend = compiler.backend;
     // If the class is an interceptor class, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     const String receiverArgumentName = r'$receiver';
 
     js.Expression buildGetter() {
       if (member.isGetter()) {
-        String getterName = namer.getterName(member.getLibrary(), member.name);
+        String getterName = namer.getterName(member);
         return new js.VariableUse('this').dot(getterName).callWith(
             isInterceptorClass
                 ? <js.Expression>[new js.VariableUse(receiverArgumentName)]
                 : <js.Expression>[]);
       } else {
         String fieldName = member.hasFixedBackendName()
             ? member.fixedBackendName()
-            : namer.instanceFieldName(memberLibrary, member.name);
+            : namer.instanceFieldName(member);
         return new js.VariableUse('this').dot(fieldName);
       }
     }
 
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
-        String invocationName =
-            namer.instanceMethodInvocationName(memberLibrary, member.name,
-                                               selector);
-        SourceString callName = namer.closureInvocationSelectorName;
-        String closureCallName =
-            namer.instanceMethodInvocationName(memberLibrary, callName,
-                                               selector);
+        String invocationName = namer.invocationName(selector);
+        Selector callSelector = new Selector.callClosureFrom(selector);
+        String closureCallName = namer.invocationName(callSelector);
 
         List<js.Parameter> parameters = <js.Parameter>[];
         List<js.Expression> arguments = <js.Expression>[];
         if (isInterceptorClass) {
           parameters.add(new js.Parameter(receiverArgumentName));
         }
 
         for (int i = 0; i < selector.argumentCount; i++) {
           String name = 'arg$i';
           parameters.add(new js.Parameter(name));
@@ skipping 303 matching lines @@
 
   String buildIsolateSetup(CodeBuffer buffer,
                            Element appMain,
                            Element isolateMain) {
     String mainAccess = "${namer.isolateAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     if (!compiler.codegenWorld.staticFunctionsNeedingGetter.contains(appMain)) {
       Selector selector = new Selector.callClosure(0);
-      String invocationName = "${namer.closureInvocationName(selector)}";
+      String invocationName = namer.invocationName(selector);
       buffer.add("$mainAccess.$invocationName = $mainAccess");
     }
     return "${namer.isolateAccess(isolateMain)}($mainAccess)";
   }
 
   emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainApp.find(Compiler.MAIN);
     String mainCall = null;
     if (compiler.hasIsolateSupport()) {
@@ skipping 275 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].
 """;