Extract CallStructure from Selector.

pkg/compiler/lib/src/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.
  *
  * Names are generated through three stages:
@@ skipping 478 matching lines @@
    * If the [originalName] is not private returns [originalName]. Otherwise
    * mangles the [originalName] so that each library has its own distinguished
    * version of the name.
    *
    * Although the name is not guaranteed to be unique within any namespace,
    * clashes are very unlikely in practice. Therefore, it can be used in cases
    * where uniqueness is nice but not a strict requirement.
    *
    * The resulting name is a *proposed name* and is never minified.
    */
-  String privateName(LibraryElement library, String originalName) {
+  String privateName(Name originalName) {
+    String text = originalName.text;
+
     // Public names are easy.
-    if (!isPrivateName(originalName)) return originalName;
+    if (!originalName.isPrivate) return text;
+
+    LibraryElement library = originalName.library;
 
     // The first library asking for a short private name wins.
     LibraryElement owner =
-        shortPrivateNameOwners.putIfAbsent(originalName, () => library);
+        shortPrivateNameOwners.putIfAbsent(text, () => library);
 
     if (owner == library) {
-      return originalName;
+      return text;
     } else {
       // Make sure to return a private name that starts with _ so it
       // cannot clash with any public names.
       // The name is still not guaranteed to be unique, since both the library
       // name and originalName could contain $ symbols.
       String libraryName = _disambiguateGlobal(library);
-      return '_$libraryName\$${originalName}';
+      return '_$libraryName\$${text}';
     }
   }
 
   String _proposeNameForConstructorBody(ConstructorBodyElement method) {
     String name = Elements.reconstructConstructorNameSourceString(method);
     // We include the method suffix on constructor bodies. It has no purpose,
     // but this way it produces the same names as previous versions of the
     // Namer class did.
     List<String> suffix = callSuffixForSignature(method.functionSignature);
     return '$name\$${suffix.join(r'$')}';
@@ skipping 25 matching lines @@
     // TODO(asgerf): Avoid clashes when named parameters contain $ symbols.
     return '$callPrefix\$${suffix.join(r'$')}';
   }
 
   /// The suffix list for the pattern:
   ///
   ///     $<N>$namedParam1...$namedParam<M>
   ///
   /// This is used for the annotated names of `call`, and for the proposed name
   /// for other instance methods.
-  List<String> callSuffixForSelector(Selector selector) {
-    List<String> suffixes = ['${selector.argumentCount}'];
-    suffixes.addAll(selector.getOrderedNamedArguments());
+  List<String> callSuffixForStructure(CallStructure callStructure) {
+    List<String> suffixes = ['${callStructure.argumentCount}'];
+    suffixes.addAll(callStructure.getOrderedNamedArguments());
     return suffixes;
   }
 
   /// The suffix list for the pattern:
   ///
   ///     $<N>$namedParam1...$namedParam<M>
   ///
   /// This is used for the annotated names of `call`, and for the proposed name
   /// for other instance methods.
   List<String> callSuffixForSignature(FunctionSignature sig) {
     List<String> suffixes = ['${sig.parameterCount}'];
     if (sig.optionalParametersAreNamed) {
       for (FormalElement param in sig.orderedOptionalParameters) {
         suffixes.add(param.name);
       }
     }
     return suffixes;
   }
 
   /// Annotated name for the member being invoked by [selector].
   String invocationName(Selector selector) {
-    LibraryElement library = selector.library;
     switch (selector.kind) {
       case SelectorKind.GETTER:
-        String disambiguatedName = _disambiguateMember(library, selector.name);
+        String disambiguatedName = _disambiguateMember(selector.memberName);
         return deriveGetterName(disambiguatedName);
 
       case SelectorKind.SETTER:
-        String disambiguatedName = _disambiguateMember(library, selector.name);
+        String disambiguatedName = _disambiguateMember(selector.memberName);
         return deriveSetterName(disambiguatedName);
 
       case SelectorKind.OPERATOR:
       case SelectorKind.INDEX:
         String operatorIdentifier = operatorNameToIdentifier(selector.name);
         String disambiguatedName = _disambiguateOperator(operatorIdentifier);
         return disambiguatedName; // Operators are not annotated.
 
       case SelectorKind.CALL:
-        List<String> suffix = callSuffixForSelector(selector);
+        List<String> suffix = callSuffixForStructure(selector.callStructure);
         if (selector.name == Compiler.CALL_OPERATOR_NAME) {
           // Derive the annotated name for this variant of 'call'.
           return deriveCallMethodName(suffix);
         }
         String disambiguatedName =
-            _disambiguateMember(library, selector.name, suffix);
+            _disambiguateMember(selector.memberName, suffix);
         return disambiguatedName; // Methods other than call are not annotated.
 
       default:
         compiler.internalError(compiler.currentElement,
             'Unexpected selector kind: ${selector.kind}');
         return null;
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
   String invocationMirrorInternalName(Selector selector)
       => invocationName(selector);
 
   /**
    * Returns the disambiguated name for the given field, used for constructing
    * the getter and setter names.
    */
-  String fieldAccessorName(Element element) {
+  String fieldAccessorName(FieldElement element) {
     return element.isInstanceMember
-        ? _disambiguateMember(element.library, element.name)
+        ? _disambiguateMember(element.memberName)
         : _disambiguateGlobal(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store a static or instance
    * field.
    */
-  String fieldPropertyName(Element element) {
+  String fieldPropertyName(FieldElement element) {
     return element.isInstanceMember
         ? instanceFieldPropertyName(element)
         : _disambiguateGlobal(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store the
    * `readTypeVariable` function for the given type variable.
    */
   String nameForReadTypeVariable(TypeVariableElement element) {
     return _disambiguateInternalMember(element, () => element.name);
   }
 
   /**
    * Returns a JavaScript property name used to store [element] on one
    * of the global objects.
    *
    * Should be used together with [globalObjectFor], which denotes the object
    * on which the returned property name should be used.
    */
   String globalPropertyName(Element element) {
     return _disambiguateGlobal(element);
   }
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
-  String instanceFieldPropertyName(Element element) {
+  String instanceFieldPropertyName(FieldElement element) {
     ClassElement enclosingClass = element.enclosingClass;
 
     if (element.hasFixedBackendName) {
       // Certain native fields must be given a specific name. Native names must
       // not contain '$'. We rely on this to avoid clashes.
       assert(enclosingClass.isNative &&
              !element.fixedBackendName.contains(r'$'));
 
       return element.fixedBackendName;
     }
@@ skipping 19 matching lines @@
     if (classWorld.isUsedAsMixin(enclosingClass) ||
         _isShadowingSuperField(element) ||
         _isUserClassExtendingNative(enclosingClass)) {
       String proposeName() => '${enclosingClass.name}_${element.name}';
       return _disambiguateInternalMember(element, proposeName);
     }
 
     // No superclass uses the disambiguated name as a property name, so we can
     // use it for this field. This generates nicer field names since otherwise
     // the field name would have to be mangled.
-    return _disambiguateMember(element.library, element.name);
+    return _disambiguateMember(element.memberName);
   }
 
   bool _isShadowingSuperField(Element element) {
     return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassElement class_) {
     return !class_.isNative &&
            Elements.isNativeOrExtendsNative(class_.superclass);
   }
 
   /// Annotated name for the setter of [element].
-  String setterForElement(Element element) {
+  String setterForElement(MemberElement element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    String name = _disambiguateMember(element.library, element.name);
+    String name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
   String deriveSetterName(String disambiguatedName) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     return '$setterPrefix$disambiguatedName';
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
   String deriveGetterName(String disambiguatedName) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
     return '$getterPrefix$disambiguatedName';
   }
 
   /// Annotated name for the getter of [element].
-  String getterForElement(Element element) {
+  String getterForElement(MemberElement element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    String name = _disambiguateMember(element.library, element.name);
+    String name = _disambiguateMember(element.memberName);
     return deriveGetterName(name);
   }
 
-  /// Property name for the getter of an instance member with [originalName]
-  /// in [library].
-  ///
-  /// [library] may be `null` if [originalName] is known to be public.
-  String getterForMember(LibraryElement library, String originalName) {
-    String disambiguatedName = _disambiguateMember(library, originalName);
+  /// Property name for the getter of an instance member with [originalName].
+  String getterForMember(Name originalName) {
+    String disambiguatedName = _disambiguateMember(originalName);
     return deriveGetterName(disambiguatedName);
   }
 
-  /// Property name for the getter or a public instance member with
-  /// [originalName].
-  String getterForPublicMember(String originalName) {
-    return getterForMember(null, originalName);
-  }
-
   /// Disambiguated name for a compiler-owned global variable.
   ///
   /// The resulting name is unique within the global-member namespace.
   String _disambiguateInternalGlobal(String name) {
     String newName = internalGlobals[name];
     if (newName == null) {
       newName = getFreshName(name, usedGlobalNames, suggestedGlobalNames);
       internalGlobals[name] = newName;
     }
     return newName;
@@ skipping 41 matching lines @@
   /// and setters) and as property name for storing methods and method stubs.
   ///
   /// [suffixes] denote an extension of [originalName] to distiguish it from
   /// other members with that name. These are used to encode the arity and
   /// named parameters to a method. Disambiguating the same [originalName] with
   /// different [suffixes] will yield different disambiguated names.
   ///
   /// The resulting name, and its associated annotated names, are unique
   /// to the ([originalName], [suffixes]) pair within the instance-member
   /// namespace.
-  String _disambiguateMember(LibraryElement library,
-                             String originalName,
+  String _disambiguateMember(Name originalName,
                              [List<String> suffixes = const []]) {
-    // For private names, a library must be given.
-    assert(isPublicName(originalName) || library != null);
-
     // Build a string encoding the library name, if the name is private.
-    String libraryKey = isPrivateName(originalName)
-            ? _disambiguateGlobal(library)
+    String libraryKey = originalName.isPrivate
+            ? _disambiguateGlobal(originalName.library)
             : '';
 
     // In the unique key, separate the name parts by '@'.
     // This avoids clashes since the original names cannot contain that symbol.
-    String key = '$libraryKey@$originalName@${suffixes.join('@')}';
+    String key = '$libraryKey@${originalName.text}@${suffixes.join('@')}';
     String newName = userInstanceMembers[key];
     if (newName == null) {
-      String proposedName = privateName(library, originalName);
+      String proposedName = privateName(originalName);
       if (!suffixes.isEmpty) {
         // In the proposed name, separate the name parts by '$', because the
         // proposed name must be a valid identifier, but not necessarily unique.
         proposedName += r'$' + suffixes.join(r'$');
       }
       newName = getFreshName(proposedName,
                              usedInstanceNames, suggestedInstanceNames,
                              sanitizeForAnnotations: true);
       userInstanceMembers[key] = newName;
     }
@@ skipping 916 matching lines @@
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }