Change signature of lookupConstructor to only require a name.

pkg/compiler/lib/src/resolution/members.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 resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 1441 matching lines @@
     });
     Selector selector = registry.getSelector(call);
     bool isSuperCall = Initializers.isSuperConstructorCall(call);
 
     ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
                                                            isSuperCall,
                                                            call);
     Selector constructorSelector =
         visitor.getRedirectingThisOrSuperConstructorSelector(call);
     FunctionElement calledConstructor =
-        lookupTarget.lookupConstructor(constructorSelector);
+        lookupTarget.lookupConstructor(constructorSelector.name);
 
     final bool isImplicitSuperCall = false;
     final String className = lookupTarget.name;
     verifyThatConstructorMatchesCall(constructor,
                                      calledConstructor,
                                      selector,
                                      isImplicitSuperCall,
                                      call,
                                      className,
                                      constructorSelector);
@@ skipping 17 matching lines @@
           classElement.library,
           0);
 
       final bool isSuperCall = true;
       ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
                                                              isSuperCall,
                                                              functionNode);
       Selector constructorSelector = new Selector.callDefaultConstructor(
           visitor.enclosingElement.library);
       Element calledConstructor = lookupTarget.lookupConstructor(
-          constructorSelector);
+          constructorSelector.name);
 
       final String className = lookupTarget.name;
       final bool isImplicitSuperCall = true;
       verifyThatConstructorMatchesCall(constructor,
                                        calledConstructor,
                                        callToMatch,
                                        isImplicitSuperCall,
                                        functionNode,
                                        className,
                                        constructorSelector);
@@ skipping 796 matching lines @@
 
     // A synthetic constructor does not have a node.
     if (node == null) return null;
     if (node.initializers == null) return null;
     Link<Node> initializers = node.initializers.nodes;
     if (!initializers.isEmpty &&
         Initializers.isConstructorRedirect(initializers.head)) {
       Selector selector =
           getRedirectingThisOrSuperConstructorSelector(initializers.head);
       final ClassElement classElement = constructor.enclosingClass;
-      return classElement.lookupConstructor(selector);
+      return classElement.lookupConstructor(selector.name);
     }
     return null;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     Element enclosingElement = function.enclosingElement;
     if (node.modifiers.isStatic &&
         enclosingElement.kind != ElementKind.CLASS) {
       compiler.reportError(node, MessageKind.ILLEGAL_STATIC);
     }
@@ skipping 2451 matching lines @@
             resolver.enclosingElement.library)
         : new Selector.callConstructor(
             constructorName,
             resolver.enclosingElement.library);
   }
 
   FunctionElement resolveConstructor(ClassElement cls,
                                      Node diagnosticNode,
                                      String constructorName) {
     cls.ensureResolved(compiler);
-    Selector selector = createConstructorSelector(constructorName);
-    Element result = cls.lookupConstructor(selector);
+    Element result = cls.lookupConstructor(constructorName);
     if (result == null) {
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               cls.name,
               constructorName);
       return failOrReturnErroneousElement(
           cls,
           diagnosticNode,
           fullConstructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName});
@@ skipping 181 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }