Normalize constructor lookup.

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.resolution.constructors;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
     GenerativeConstantConstructor,
     RedirectingGenerativeConstantConstructor;
@@ skipping 150 matching lines @@
       visitor.resolveSelector(call, null);
       return visitor.resolveArguments(call.argumentsNode);
     }, inConstantInitializer: isConst);
 
     bool isSuperCall = Initializers.isSuperConstructorCall(call);
     InterfaceType targetType =
         getSuperOrThisLookupTarget(call, isSuperCall: isSuperCall);
     ClassElement lookupTarget = targetType.element;
     Selector constructorSelector =
         visitor.getRedirectingThisOrSuperConstructorSelector(call);
-    FunctionElement calledConstructor =
-        lookupTarget.lookupConstructor(constructorSelector.name);
+    ConstructorElement calledConstructor = findConstructor(
+        constructor.library, lookupTarget, constructorSelector.name);
 
     final bool isImplicitSuperCall = false;
     final String className = lookupTarget.name;
     verifyThatConstructorMatchesCall(calledConstructor,
                                      argumentsResult.callStructure,
                                      isImplicitSuperCall,
                                      call,
                                      className,
                                      constructorSelector);
 
@@ skipping 25 matching lines @@
     ClassElement classElement = constructor.enclosingClass;
     ClassElement superClass = classElement.superclass;
     if (classElement != visitor.compiler.objectClass) {
       assert(superClass != null);
       assert(superClass.isResolved);
 
       InterfaceType targetType =
           getSuperOrThisLookupTarget(functionNode, isSuperCall: true);
       ClassElement lookupTarget = targetType.element;
       Selector constructorSelector = new Selector.callDefaultConstructor();
-      Element calledConstructor = lookupTarget.lookupConstructor(
+      ConstructorElement calledConstructor = findConstructor(
+          constructor.library,
+          lookupTarget,
           constructorSelector.name);
 
       final String className = lookupTarget.name;
       final bool isImplicitSuperCall = true;
       verifyThatConstructorMatchesCall(calledConstructor,
                                        CallStructure.NO_ARGS,
                                        isImplicitSuperCall,
                                        functionNode,
                                        className,
                                        constructorSelector);
@@ skipping 228 matching lines @@
     }
     return new ConstructorResult(resultKind, error, type);
   }
 
   ConstructorResult resolveConstructor(
       InterfaceType type,
       Node diagnosticNode,
       String constructorName) {
     ClassElement cls = type.element;
     cls.ensureResolved(compiler);
-    ConstructorElement constructor = cls.lookupConstructor(constructorName);
-    // TODO(johnniwinther): Use [Name] for lookup.
-    if (Name.isPrivateName(constructorName) &&
-        resolver.enclosingElement.library != cls.library) {
-      constructor = null;
-    }
+    ConstructorElement constructor = findConstructor(
+        resolver.enclosingElement.library, cls, constructorName);
     if (constructor == null) {
       String fullConstructorName =
           Elements.constructorNameForDiagnostics(cls.name, constructorName);
       return reportAndCreateErroneousConstructorElement(
           diagnosticNode,
           ConstructorResultKind.UNRESOLVED_CONSTRUCTOR, type,
           cls, constructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName},
           missingConstructor: true);
@@ skipping 238 matching lines @@
       sb.write('type=$type');
     } else if (element != null) {
       sb.write('element=$element');
     } else {
       sb.write('type=$type');
     }
     sb.write(')');
     return sb.toString();
   }
 }
+
+/// Lookup the [constructorName] constructor in [cls] and normalize the result
+/// with respect to privacy and patching.
+ConstructorElement findConstructor(
+    LibraryElement currentLibrary,
+    ClassElement cls,
+    String constructorName) {
+  if (Name.isPrivateName(constructorName) &&
+      currentLibrary.library != cls.library) {
+    // TODO(johnniwinther): Report a special error on unaccessible private
+    // constructors.
+    return null;
+  }
+  // TODO(johnniwinther): Use [Name] for lookup.
+  ConstructorElement constructor = cls.lookupConstructor(constructorName);
+  if (constructor != null) {
+    constructor = constructor.declaration;
+  }
+  return constructor;
+}