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

lib/compiler/implementation/universe/universe.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('universe');
 
 #import('../closure.dart');
 #import('../elements/elements.dart');
 #import('../leg.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 76 matching lines @@
 
   static const SelectorKind GETTER = const SelectorKind('getter');
   static const SelectorKind SETTER = const SelectorKind('setter');
   static const SelectorKind CALL = const SelectorKind('call');
   static const SelectorKind OPERATOR = const SelectorKind('operator');
   static const SelectorKind INDEX = const SelectorKind('index');
 
   toString() => name;
 }
 
+class SelectorName {

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

I'm not quite happy with this abstraction. Why do all selectors (indirectly)
need a class name? Why do we have both a library name and the real library in
all selectors? It seems a bit ... weird to me :-)

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

Main reason for having library in SelectorName and library in Selector is that
first one is part of the name(as in lib.A), while second one is context from
where you are looking for that lib.A. Second "context" library name in Selector
only makes sense for private names selectors.

+  final SourceString libName;
+  final SourceString className;
+  final SourceString name;
+
+  SourceString _fullName;
+
+  SelectorName(name, {libName: const SourceString('')})

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

It makes me a bit uncomfortable to have these defaults for library names that
just happen to usually be empty. If we can make the resolver build all these
selectors, it would be nice if it could always pass the current library into the
factory methods -- not using defaults of any kind. It's fine if the selector
ignores the library unless the name indicates that the selector is private.

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

This libName represents names which have library name explicitly specified as in
"var x = new lib1.clsClass();" or in "var y = new
lib2.clsClass.namedConstructor();".
Right?

+      : this.fullyNamed(libName, const SourceString(''), name);
+  SelectorName.namedClass(className, {libName: const SourceString('')})
+      : this.fullyNamed(libName, className, const SourceString(''));
+  SelectorName.namedConstructor(className,
+                                name,
+                                {libName: const SourceString('')})
+      : this.fullyNamed(libName, className, name);
+
+  SelectorName.fullyNamed(this.libName, this.className, this.name) {
+    String fn = name.slowToString();
+    String cn = className.slowToString();
+    if (cn.length > 0) {
+      if (fn.length > 0) {
+        cn = cn.concat(".");
+      }
+      fn = cn.concat(fn);
+    }
+    String ln = libName.slowToString();
+    if (ln.length > 0) {
+      if (fn.length >0 ) {
+        ln = ln.concat(".");
+      }
+      fn = ln.concat(fn);
+    }
+    this._fullName = new SourceString(fn);
+  }
+
+  toString() => _fullName.stringValue;
+  isPrivate() => name.isPrivate();
+}
+
 class Selector implements Hashable {
   final SelectorKind kind;
-  final SourceString name;
+  final SelectorName selectorName;
+  SourceString get name => selectorName._fullName;
+
   final LibraryElement library; // Library is null for non-private selectors.
 
   // The numbers of arguments of the selector. Includes named arguments.
   final int argumentCount;
   final List<SourceString> namedArguments;
   final List<SourceString> orderedNamedArguments;
 
   Selector(
+      kind,
+      SourceString name,
+      LibraryElement library,
+      argumentCount,
+      [List<SourceString> namedArguments = const <SourceString>[]])
+    : this.fromSelectorName(kind,
+                            new SelectorName(name),
+                            library,
+                            argumentCount,
+                            namedArguments);
+
+  Selector.fromSelectorName(
       this.kind,
-      SourceString name,
+      SelectorName selectorName,
       LibraryElement library,
       this.argumentCount,
       [List<SourceString> namedArguments = const <SourceString>[]])
-    : this.name = name,
-      this.library = name.isPrivate() ? library : null,
+    : this.selectorName = selectorName,
+      this.library = selectorName.isPrivate() ? library : null,
       this.namedArguments = namedArguments,
       this.orderedNamedArguments = namedArguments.isEmpty()
           ? namedArguments
           : <SourceString>[] {
-    assert(!name.isPrivate() || library != null);
+    assert(!selectorName.isPrivate() || library != null);
   }
 
   Selector.getter(SourceString name, LibraryElement library)
       : this(SelectorKind.GETTER, name, library, 0);
 
   Selector.getterFrom(Selector selector)
       : this(SelectorKind.GETTER, selector.name, selector.library, 0);
 
   Selector.setter(SourceString name, LibraryElement library)
       : this(SelectorKind.SETTER, name, library, 1);
@@ skipping 17 matching lines @@
       : this(SelectorKind.INDEX,
              Elements.constructOperatorName(const SourceString("[]="), false),
              null, 2);
 
   Selector.call(SourceString name,
                 LibraryElement library,
                 int arity,
                 [List<SourceString> named = const []])
       : this(SelectorKind.CALL, name, library, arity, named);
 
+  // Ignore arity and named parameters when creating constructor selector
+  // since constructors are uniquely identifed by name only, can't be
+  // overriden.
+  Selector.callConstructor(SelectorName name,

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

This looks nice and it looks like a good place to maybe take two arguments --
one with the class name and one with the constructor name. If you're given a
constructor name you can check that too see if the selector is private.

You could even add a Selector.callDefaultConstructor that only takes a class
name.

+                           LibraryElement library)
+      : this.fromSelectorName(SelectorKind.CALL, name, library, 0, const []);
+
   Selector.callClosure(int arity, [List<SourceString> named = const []])
       : this(SelectorKind.CALL, Compiler.CALL_OPERATOR_NAME, null,
              arity, named);
 
   Selector.callClosureFrom(Selector selector)
       : this(SelectorKind.CALL, Compiler.CALL_OPERATOR_NAME, null,
              selector.argumentCount, selector.namedArguments);
 
   // TODO(kasperl): This belongs somewhere else.
   Selector.noSuchMethod()
@@ skipping 329 matching lines @@
 
     if (!self.isInterface() && self.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && appliesUntyped(element, compiler);
     }
 
     return false;
   }
 }