Stop passing library elements to tons of namer functions.

sdk/lib/_internal/compiler/implementation/js_backend/namer.dart

 // Copyright (c) 2011, 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;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 81 matching lines @@
         }
       } else {
         longName = "CONSTANT";
       }
       result = getFreshName(longName, usedGlobalNames);
       constantNames[constant] = result;
     }
     return result;
   }
 
-  String closureInvocationName(Selector selector) {
-    return instanceMethodInvocationName(null, closureInvocationSelectorName,
-                                        selector);
-  }
-
   String breakLabelName(LabelElement label) {
     return '\$${label.labelName}\$${label.target.nestingLevel}';
   }
 
   String implicitBreakLabelName(TargetElement target) {
     return '\$${target.nestingLevel}';
   }
 
   // We sometimes handle continue targets differently from break targets,
   // so we have special continue-only labels.
   String continueLabelName(LabelElement label) {
     return 'c\$${label.labelName}\$${label.target.nestingLevel}';
   }
 
   String implicitContinueLabelName(TargetElement target) {
     return 'c\$${target.nestingLevel}';
   }
 
   /**
    * If the [name] is not private returns [:name.slowToString():]. Otherwise
    * mangles the [name] so that each library has a unique name.
    */
-  String privateName(LibraryElement lib, SourceString name) {
-    String result;
-    if (name.isPrivate()) {
-      String nameString = name.slowToString();
-      // The first library asking for a short private name wins.
-      LibraryElement owner = shouldMinify ?
-          lib :
-          shortPrivateNameOwners.putIfAbsent(nameString, () => lib);
-      // If a private name could clash with a mangled private name we don't
-      // use the short name. For example a private name "_lib3_foo" would
-      // clash with "_foo" from "lib3".
-      if (owner == lib &&
-          !nameString.startsWith('_$LIBRARY_PREFIX') &&
-          !shouldMinify) {
-        result = nameString;
-      } else {
-        String libName = getName(lib);
-        // If a library name does not start with the [LIBRARY_PREFIX] then our
-        // assumptions about clashing with mangled private members do not hold.
-        assert(shouldMinify || libName.startsWith(LIBRARY_PREFIX));
-        // TODO(erikcorry): Fix this with other manglings to avoid clashes.
-        result = '_lib$libName\$$nameString';
-      }
-    } else {
-      result = name.slowToString();
+  String privateName(LibraryElement library, SourceString name) {
+    // Public names are easy.
+    String nameString = name.slowToString();
+    if (!name.isPrivate()) return nameString;
+
+    // The first library asking for a short private name wins.
+    LibraryElement owner = shouldMinify
+        ? library
+        : shortPrivateNameOwners.putIfAbsent(nameString, () => library);
+
+    // If a private name could clash with a mangled private name we don't
+    // use the short name. For example a private name "_lib3_foo" would
+    // clash with "_foo" from "lib3".
+    if (owner == library &&
+        !nameString.startsWith('_$LIBRARY_PREFIX') &&
+        !shouldMinify) {
+      return nameString;
     }
-    return result;
+
+    // If a library name does not start with the [LIBRARY_PREFIX] then our
+    // assumptions about clashing with mangled private members do not hold.
+    String libraryName = getName(library);
+    assert(shouldMinify || libraryName.startsWith(LIBRARY_PREFIX));
+    // TODO(erikcorry): Fix this with other manglings to avoid clashes.
+    return '_library$libraryName\$$nameString';

[ngeoffray, 2013/01/11 10:29:11]

Note that you just changed the name to start with 'library' instead of 'lib'.

   }
 
   String instanceMethodName(FunctionElement element) {
     SourceString name = Elements.operatorNameToIdentifier(element.name);
-    LibraryElement lib = element.getLibrary();
+    LibraryElement library = element.getLibrary();
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
       ConstructorBodyElement bodyElement = element;
       name = bodyElement.constructor.name;
     }
     FunctionSignature signature = element.computeSignature(compiler);
     String methodName =
-        '${privateName(lib, name)}\$${signature.parameterCount}';
+        '${privateName(library, name)}\$${signature.parameterCount}';
     if (signature.optionalParametersAreNamed &&
         !signature.optionalParameters.isEmpty) {
       StringBuffer buffer = new StringBuffer();
       signature.orderedOptionalParameters.forEach((Element element) {
         buffer.add('\$${JsNames.getValid(element.name.slowToString())}');
       });
       methodName = '$methodName$buffer';
     }
     if (name == closureInvocationSelectorName) return methodName;
     return getMappedInstanceName(methodName);
   }
 
   String publicInstanceMethodNameByArity(SourceString name, int arity) {
     name = Elements.operatorNameToIdentifier(name);
     assert(!name.isPrivate());
     var base = name.slowToString();
     // We don't mangle the closure invoking function name because it is
     // generated in by string concatenation applyFunction from js_helper.dart.
     var proposedName = '$base\$$arity';
     if (base == closureInvocationSelectorName) return proposedName;
     return getMappedInstanceName(proposedName);
   }
 
-  String instanceMethodInvocationName(LibraryElement lib, SourceString name,
-                                      Selector selector) {
-    name = Elements.operatorNameToIdentifier(name);
-    // TODO(floitsch): mangle, while preserving uniqueness.
-    StringBuffer buffer = new StringBuffer();
-    List<SourceString> names = selector.getOrderedNamedArguments();
-    for (SourceString argumentName in names) {
-      buffer.add(r'$');
-      argumentName.printOn(buffer);
+  String invocationName(Selector selector) {
+    if (selector.isGetter()) {
+      String proposedName = privateName(selector.library, selector.name);
+      return 'get\$${getMappedInstanceName(proposedName)}';
+    } else if (selector.isSetter()) {
+      String proposedName = privateName(selector.library, selector.name);
+      return 'set\$${getMappedInstanceName(proposedName)}';
+    } else {
+      assert(selector.isCall());
+      SourceString name = Elements.operatorNameToIdentifier(selector.name);
+      StringBuffer buffer = new StringBuffer();
+      for (SourceString argumentName in selector.getOrderedNamedArguments()) {
+        buffer.add(r'$');
+        argumentName.printOn(buffer);
+      }
+      String suffix = '\$${selector.argumentCount}$buffer';
+      // We don't mangle the closure invoking function name because it
+      // is generated in by string concatenation applyFunction from

[ngeoffray, 2013/01/11 10:29:11]

in by string concatenation applyFunction -> by string concatenation in
applyFunction.

+      // js_helper.dart.
+      if (selector.isClosureCall()) return "$name$suffix";
+      String proposedName = privateName(selector.library, name);
+      return getMappedInstanceName('$proposedName$suffix');
     }
-    if (name == closureInvocationSelectorName) {
-    // We don't mangle the closure invoking function name because it is
-    // generated in by string concatenation applyFunction from js_helper.dart.
-      return '$closureInvocationSelectorName\$${selector.argumentCount}$buffer';
-    }
-    return getMappedInstanceName(
-        '${privateName(lib, name)}\$${selector.argumentCount}$buffer');
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
-  String invocationMirrorInternalName(Selector selector) {
-    if (selector.isGetter()) {
-      return getterName(selector.library, selector.name);
-    } else if (selector.isSetter()) {
-      return setterName(selector.library, selector.name);
-    } else {
-      return instanceMethodInvocationName(
-          selector.library, selector.name, selector);
-    }
-  }
+  String invocationMirrorInternalName(Selector selector)
+      => invocationName(selector);
 
-  String instanceFieldName(LibraryElement libraryElement, SourceString name) {
-    String proposedName = privateName(libraryElement, name);
+  String instanceFieldName(Element element) {
+    String proposedName = privateName(element.getLibrary(), element.name);
     return getMappedInstanceName(proposedName);
   }
 
   // Construct a new name for the element based on the library and class it is
   // in.  The name here is not important, we just need to make sure it is
   // unique.  If we are minifying, we actually construct the name from the
   // minified versions of the class and instance names, but the result is
   // minified once again, so that is not visible in the end result.
   String shadowedFieldName(Element fieldElement) {
     // Check for following situation: Native field ${fieldElement.name} has
     // fixed JSName ${fieldElement.nativeName()}, but a subclass shadows this
     // name.  We normally handle that by renaming the superclass field, but we
     // can't do that because native fields have fixed JsNames.  In practice
     // this can't happen because we can't inherit from native classes.
     assert (!fieldElement.hasFixedBackendName());
 
-    ClassElement cls = fieldElement.getEnclosingClass();
-    LibraryElement libraryElement = fieldElement.getLibrary();
-    String libName = getName(libraryElement);
-    String clsName = getName(cls);
-    String instanceName = instanceFieldName(libraryElement, fieldElement.name);
-    return getMappedInstanceName('$libName\$$clsName\$$instanceName');
+    String libraryName = getName(fieldElement.getLibrary());
+    String className = getName(fieldElement.getEnclosingClass());
+    String instanceName = instanceFieldName(fieldElement);
+    return getMappedInstanceName('$libraryName\$$className\$$instanceName');
   }
 
-  String setterName(LibraryElement lib, SourceString name) {
+  String setterName(Element element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    String fieldName = getMappedInstanceName(privateName(lib, name));
-    return 'set\$$fieldName';
+    LibraryElement library = element.getLibrary();
+    String name = getMappedInstanceName(privateName(library, element.name));
+    return 'set\$$name';
   }
 
   String setterNameFromAccessorName(String name) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     return 'set\$$name';
   }
 
   String publicGetterName(SourceString name) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
     String fieldName = getMappedInstanceName(name.slowToString());
     return 'get\$$fieldName';
   }
 
   String getterNameFromAccessorName(String name) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
     return 'get\$$name';
   }
 
-  String getterName(LibraryElement lib, SourceString name) {
+  String getterName(Element element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    String fieldName = getMappedInstanceName(privateName(lib, name));
-    return 'get\$$fieldName';
+    LibraryElement library = element.getLibrary();
+    String name = getMappedInstanceName(privateName(library, element.name));
+    return 'get\$$name';
   }
 
   String getMappedGlobalName(String proposedName) {
     var newName = globalNameMap[proposedName];
     if (newName == null) {
       newName = getFreshName(proposedName, usedGlobalNames);
       globalNameMap[proposedName] = newName;
     }
     return newName;
   }
@@ skipping 30 matching lines @@
   }
 
   static const String LIBRARY_PREFIX = "lib";
 
   /**
    * Returns a preferred JS-id for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
   String _computeGuess(Element element) {
     assert(!element.isInstanceMember());
-    LibraryElement lib = element.getLibrary();
     String name;
     if (element.isGenerativeConstructor()) {
       if (element.name == element.getEnclosingClass().name) {
         // Keep the class name for the class and not the factory.
         name = "${element.name.slowToString()}\$";
       } else {
         name = element.name.slowToString();
       }
     } else if (Elements.isStaticOrTopLevel(element)) {
       if (element.isMember()) {
@@ skipping 52 matching lines @@
    *
    * For accessing statics consider calling
    * [isolateAccess]/[isolateBailoutAccess] or [isolatePropertyAccess] instead.
    */
   String getName(Element element) {
     if (element.isInstanceMember()) {
       if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY
           || element.kind == ElementKind.FUNCTION) {
         return instanceMethodName(element);
       } else if (element.kind == ElementKind.GETTER) {
-        return getterName(element.getLibrary(), element.name);
+        return getterName(element);
       } else if (element.kind == ElementKind.SETTER) {
-        return setterName(element.getLibrary(), element.name);
+        return setterName(element);
       } else if (element.kind == ElementKind.FIELD) {
-        return instanceFieldName(element.getLibrary(), element.name);
+        return instanceFieldName(element);
       } else {
         compiler.internalError('getName for bad kind: ${element.kind}',
                                node: element.parseNode(compiler));
       }
     } else {
       // Use declaration element to ensure invariant on [globals].
       element = element.declaration;
       // Dealing with a top-level or static element.
       String cached = globals[element];
       if (cached != null) return cached;
@@ skipping 59 matching lines @@
   }
 
   String safeName(String name) {
     if (jsReserved.contains(name) || name.startsWith('\$')) {
       name = "\$$name";
       assert(!jsReserved.contains(name));
     }
     return name;
   }
 }