Made dart2js constructor lookup logic "private"-aware, fixed 4740 bug.

lib/compiler/implementation/resolver.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 71 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)) {
       final ClassElement classElement = constructor.getEnclosingClass();
       final SourceString constructorName =
           getConstructorName(initializers.head);
       final SourceString className = classElement.name;
-      return classElement.lookupConstructor(className, constructorName);
+      return classElement.lookupConstructor(constructor.getLibrary(),
+                                            className,
+                                            constructorName);
     }
     return null;
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
                                      Node node,
                                      FunctionElement constructor,
                                      FunctionElement redirection) {
     Set<FunctionElement> seen = new Set<FunctionElement>();
     seen.add(constructor);
@@ skipping 75 matching lines @@
     // of the interface.
     SourceString name;
     if (defaultClass.implementsInterface(intrface)) {
       // TODO(ahe): Don't use string replacement here.
       name = new SourceString(constructor.name.slowToString().replaceFirst(
                  intrface.name.slowToString(),
                  defaultClass.name.slowToString()));
     } else {
       name = constructor.name;
     }
-    constructor.defaultImplementation = defaultClass.lookupConstructor(name);
+    constructor.defaultImplementation =
+        defaultClass.lookupConstructor(defaultClass.getLibrary(),
+                                       name);
 
     if (constructor.defaultImplementation === null) {
       // We failed to find a constructor named either
       // "MyInterface.name" or "MyClass.name".
       error(node,
             MessageKind.CANNOT_FIND_CONSTRUCTOR2,
             [name, defaultClass.name]);
     }
   }
 
@@ skipping 386 matching lines @@
       if (lookupTarget === visitor.compiler.objectClass) {
         error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
       } else {
         lookupTarget = lookupTarget.supertype.element;
       }
     }
 
     // Lookup constructor and try to match it to the selector.
     ResolverTask resolver = visitor.compiler.resolver;
     final SourceString className = lookupTarget.name;
-    result = lookupTarget.lookupConstructor(className, constructorName);
+    result =
+      lookupTarget.lookupConstructor(constructor.getLibrary(),
+                                     className,
+                                     constructorName);
     if (result === null || !result.isGenerativeConstructor()) {
       String classNameString = className.slowToString();
       String constructorNameString = constructorName.slowToString();
       String name = (constructorName === const SourceString(''))
                         ? classNameString
                         : "$classNameString.$constructorNameString";
       MessageKind kind = isImplicitSuperCall
                          ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
                          : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
       error(diagnosticNode, kind, [name]);
@@ skipping 1983 matching lines @@
       compiler.reportWarning(diagnosticNode, warning);
       return new ErroneousFunctionElement(warning.message, targetName,
                                           enclosing);
     }
   }
 
   FunctionElement lookupConstructor(ClassElement cls,
                                     Node diagnosticNode,
                                     SourceString constructorName) {
     cls.ensureResolved(compiler);
-    Element result = cls.lookupConstructor(cls.name, constructorName);
+    Element result =
+        cls.lookupConstructor(resolver.enclosingElement.getLibrary(),
+                              cls.name,
+                              constructorName);
     if (result === null) {
       String fullConstructorName = cls.name.slowToString();
       if (constructorName !== const SourceString('')) {
         fullConstructorName = '$fullConstructorName'
                               '.${constructorName.slowToString()}';
       }
       return failOrReturnErroneousElement(cls, diagnosticNode,
                                           new SourceString(fullConstructorName),
                                           MessageKind.CANNOT_FIND_CONSTRUCTOR,
                                           [fullConstructorName]);
@@ skipping 207 matching lines @@
 
   Element localLookup(SourceString name) => library.find(name);
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }