Revert "Extract CallStructure from Selector."

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 319 matching lines @@
       // TODO(ahe): Enable the next line when I can tell the difference between
       // an instance method and a global.  They may have the same mangled name.
       // if (recordedMangledNames.contains(mangledName)) return null;
       recordedMangledNames.add(mangledName);
       return getReflectionNameInternal(elementOrSelector, mangledName);
     }
     return null;
   }
 
   String getReflectionNameInternal(elementOrSelector, String mangledName) {
-    String name = namer.privateName(elementOrSelector.memberName);
+    String name =
+        namer.privateName(elementOrSelector.library, elementOrSelector.name);
     if (elementOrSelector.isGetter) return name;
     if (elementOrSelector.isSetter) {
       if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
       String base = mangledName.substring(namer.setterPrefix.length);
       String getter = '${namer.getterPrefix}$base';
       mangledFieldNames.putIfAbsent(getter, () => name);
       assert(mangledFieldNames[getter] == name);
       recordedMangledNames.add(getter);
       // TODO(karlklose,ahe): we do not actually need to store information
       // about the name of this setter in the output, but it is needed for
       // marking the function as invokable by reflection.
       return '$name=';
     }
     if (elementOrSelector is Element && elementOrSelector.isClosure) {
       // Closures are synthesized and their name might conflict with existing
       // globals. Assign an illegal name, and make sure they don't clash
       // with each other.
       return " $mangledName";
     }
     if (elementOrSelector is Selector
         || elementOrSelector.isFunction
         || elementOrSelector.isConstructor) {
       int positionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
-        CallStructure callStructure = elementOrSelector.callStructure;
-        positionalParameterCount = callStructure.positionalArgumentCount;
-        namedArguments = namedParametersAsReflectionNames(callStructure);
+        Selector selector = elementOrSelector;
+        positionalParameterCount = selector.positionalArgumentCount;
+        namedArguments = namedParametersAsReflectionNames(selector);
       } else {
         FunctionElement function = elementOrSelector;
         if (function.isConstructor) {
           isConstructor = true;
           name = Elements.reconstructConstructorName(function);
         }
         FunctionSignature signature = function.functionSignature;
         positionalParameterCount = signature.requiredParameterCount;
         if (signature.optionalParametersAreNamed) {
           var names = [];
           for (Element e in signature.optionalParameters) {
             names.add(e.name);
           }
-          CallStructure callStructure =
-              new CallStructure(positionalParameterCount, names);
-          namedArguments = namedParametersAsReflectionNames(callStructure);
+          Selector selector = new Selector.call(
+              function.name,
+              function.library,
+              positionalParameterCount,
+              names);
+          namedArguments = namedParametersAsReflectionNames(selector);
         } else {
           // Named parameters are handled differently by mirrors. For unnamed
           // parameters, they are actually required if invoked
           // reflectively. Also, if you have a method c(x) and c([x]) they both
           // get the same mangled name, so they must have the same reflection
           // name.
           positionalParameterCount += signature.optionalParameterCount;
         }
       }
       String suffix = '$name:$positionalParameterCount$namedArguments';
       return (isConstructor) ? 'new $suffix' : suffix;
     }
     Element element = elementOrSelector;
     if (element.isGenerativeConstructorBody) {
       return null;
     } else if (element.isClass) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name;
     } else if (element.isTypedef) {
       return element.name;
     }
     throw compiler.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
-  String namedParametersAsReflectionNames(CallStructure structure) {
-    if (structure.isUnnamed) return '';
-    String names = structure.getOrderedNamedArguments().join(':');
+  String namedParametersAsReflectionNames(Selector selector) {
+    if (selector.getOrderedNamedArguments().isEmpty) return '';
+    String names = selector.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
   jsAst.Statement buildCspPrecompiledFunctionFor(
       OutputUnit outputUnit) {
     // TODO(ahe): Compute a hash code.
     // TODO(sigurdm): Avoid this precompiled function. Generated
     // constructor-functions and getter/setter functions can be stored in the
     // library-description table. Setting properties on these can be moved to
     // finishClasses.
@@ skipping 1431 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }