Stop passing library elements to tons of namer functions.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1541 matching lines @@
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
         world.registerInstantiatedClass(compiler.listClass);
       } else if (target == backend.jsStringConcat) {
         push(new js.Binary('+', object, arguments[0]), node);
         return;
       }
     }
 
     if (methodName == null) {
-      methodName = backend.namer.instanceMethodInvocationName(
-          node.selector.library, name, node.selector);
+      methodName = backend.namer.invocationName(node.selector);
       bool inLoop = node.block.enclosingLoopHeader != null;
 
       Selector selector = getOptimizedSelectorFor(node, node.selector);
       if (node.isInterceptorCall) {
         backend.addInterceptedSelector(selector);
       }
       // Register this invocation to collect the types used at all call sites.
       backend.registerDynamicInvocation(node, selector, types);
 
       // If we don't know what we're calling or if we are calling a getter,
@@ skipping 38 matching lines @@
         !identical(receiverType.kind, TypeKind.MALFORMED_TYPE)) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     Selector setter = node.selector;
-    String name = backend.namer.setterName(setter.library, setter.name);
+    String name = backend.namer.invocationName(setter);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     Selector selector = getOptimizedSelectorFor(node, setter);
     world.registerDynamicSetter(setter.name, selector);
     HType valueType;
     if (node.isInterceptorCall) {
       valueType = types[node.inputs[2]];
       backend.addInterceptedSelector(setter);
     } else {
       valueType = types[node.inputs[1]];
     }
     backend.addedDynamicSetter(selector, valueType);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     Selector getter = node.selector;
-    String name = backend.namer.getterName(getter.library, getter.name);
+    String name = backend.namer.invocationName(getter);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicGetter(
         getter.name, getOptimizedSelectorFor(node, getter));
     if (node.isInterceptorCall) {
       backend.addInterceptedSelector(getter);
     }
     world.registerInstantiatedClass(compiler.functionClass);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
+    Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(jsPropertyCall(pop(),
-                        backend.namer.closureInvocationName(node.selector),
+                        backend.namer.invocationName(call),
                         visitArguments(node.inputs)),
          node);
-    Selector call = new Selector.callClosureFrom(node.selector);
     world.registerDynamicInvocation(call.name, call);
     // A closure can also be invoked through [HInvokeDynamicMethod] by
     // explicitly calling the [:call:] method. Therefore, we must also
     // register types here to let the backend invalidate wrong
     // optimizations.
     backend.registerDynamicInvocation(node, call, types);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     if (node.typeCode() == HInstruction.INVOKE_STATIC_TYPECODE) {
       // Register this invocation to collect the types used at all call sites.
       backend.registerStaticInvocation(node, types);
     }
     use(node.target);
     push(new js.Call(pop(), visitArguments(node.inputs)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     Element superClass = superMethod.getEnclosingClass();
     if (superMethod.kind == ElementKind.FIELD) {
       ClassElement currentClass = work.element.getEnclosingClass();
       if (currentClass.isClosure()) {
         ClosureClassElement closure = currentClass;
         currentClass = closure.methodElement.getEnclosingClass();
       }
-      String fieldName;
-      if (currentClass.isShadowedByField(superMethod)) {
-        fieldName = backend.namer.shadowedFieldName(superMethod);
-      } else {
-        LibraryElement library = superMethod.getLibrary();
-        SourceString name = superMethod.name;
-        fieldName = backend.namer.instanceFieldName(library, name);
-      }
+      String fieldName = currentClass.isShadowedByField(superMethod)
+          ? backend.namer.shadowedFieldName(superMethod)
+          : backend.namer.instanceFieldName(superMethod);
       use(node.inputs[1]);
       js.PropertyAccess access =
           new js.PropertyAccess.field(pop(), fieldName);
       if (node.isSetter) {
         use(node.value);
         push(new js.Assignment(access, pop()), node);
       } else {
         push(access, node);
       }
     } else {
-      String methodName;
-      if (superMethod.kind == ElementKind.FUNCTION ||
-          superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-        methodName = backend.namer.instanceMethodName(superMethod);
-      } else if (superMethod.kind == ElementKind.GETTER) {
-        methodName =
-            backend.namer.getterName(currentLibrary, superMethod.name);
-      } else {
-        assert(superMethod.kind == ElementKind.SETTER);
-        methodName =
-            backend.namer.setterName(currentLibrary, superMethod.name);
-      }
+      String methodName = backend.namer.getName(superMethod);
       String className = backend.namer.isolateAccess(superClass);
       js.VariableUse classReference = new js.VariableUse(className);
       js.PropertyAccess prototype =
           new js.PropertyAccess.field(classReference, "prototype");
       js.PropertyAccess method =
           new js.PropertyAccess.field(prototype, methodName);
       push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
     }
     world.registerStaticUse(superMethod);
   }
@@ skipping 1322 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }