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

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 1257 matching lines @@
     }
     SourceString fieldName = fieldMember.name;
     while (true) {
       Element foundMember = lookupClass.lookupMember(fieldName);
       if (foundMember == fieldMember) return false;
       if (foundMember.isField()) return true;
       lookupClass = foundMember.getEnclosingClass().superclass;
     }
   }
 
-  Element lookupConstructor(SourceString className,
-                            [SourceString constructorName =
-                                 const SourceString(''),
-                            Element noMatch(Element)]) {
+  Element lookupConstructor(Selector selector, [Element noMatch(Element)]) {
+    SourceString className = selector.selectorName.className;

[kasperl, 2012/09/21 12:12:06]

This makes it look like all you really need is to have the name you stuff in the
selector be pre-normalized somehow so that it contains everything you need to do
the lookup?

I understand there may be some complications in figuring out a selector is
private or not (based on the name alone), but maybe we could change
Selector.isPrivate to say yes if Selector.library != null and let the name in a
selector for a private named constructor be something like 'C._internal'?

[aam-me, 2012/09/21 12:35:27]

Right.
Right, we can do that. My thoughts we that storing name normalized (lib name,
class name, constructor name) is better than parsing name every time we do
lookup. But then again, parsing here is just splitting by '.', so it is not that
expensive. 

+    SourceString constructorName = selector.selectorName.name;
+
+    LibraryElement fromLibrary = selector.library;
     // TODO(karlklose): have a map from class names to a map of constructors
     //                  instead of creating the name here?
     SourceString normalizedName;
     if (constructorName !== const SourceString('')) {
       normalizedName = Elements.constructConstructorName(className,
                                                          constructorName);
     } else {
       normalizedName = className;
     }
     Element result = localLookup(normalizedName);
-    if (result === null || !result.isConstructor()) {
+    if (result === null
+        || !result.isConstructor()
+        || (selector.selectorName.isPrivate()
+            && result.getLibrary() != fromLibrary)) {
       result = noMatch !== null ? noMatch(result) : null;
     }
     return result;
   }
 
   bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.getValues()) {
       if (element.isConstructor()) return true;
     }
@@ skipping 388 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }