Fix field-accesses for private fields that were "shadowed" by other private fields.

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 680 matching lines @@
   }
 
   position() {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
     // non-null and defined in the same compilation unit as the
     // abstract element.
     //
     // We need to make sure that the position returned is relative to
     // the compilation unit of the abstract element.
-    if (getter !== null 
+    if (getter !== null
         && getter.getCompilationUnit() === getCompilationUnit()) {
       return getter.position();
     } else {
       return setter.position();
     }
   }
 
   Modifiers get modifiers() {
     // The resolver ensures that the flags match (ignoring abstract).
     if (getter !== null) {
@@ skipping 334 matching lines @@
   /**
    * Lookup local members in the class. This will ignore constructors.
    */
   Element lookupLocalMember(SourceString memberName) {
     var result = localLookup(memberName);
     if (result !== null && result.isConstructor()) return null;
     return result;
   }
 
   /**
-  * Lookup super members for the class. This will ignore constructors.
+   * Lookup super members for the class. This will ignore constructors.
    */
   Element lookupSuperMember(SourceString memberName) {
+    return lookupSuperMemberInLibrary(memberName, getLibrary());
+  }
+
+  /**
+   * Lookup super members for the class that is accessible in [library].
+   * This will ignore constructors.
+   */
+  Element lookupSuperMemberInLibrary(SourceString memberName,

[kasperl, 2012/08/16 12:47:57]

Would it be possible to start using Selector for looking up stuff? The selector
has a name and a library...

[floitsch, 2012/08/16 16:15:55]

Went a little bit into that direction. It's not complete but better than before.

+                                     LibraryElement library) {
     bool isPrivate = memberName.isPrivate();
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       // Private members from a different library are not visible.
-      if (isPrivate && getLibrary() !== s.getLibrary()) continue;
+      if (isPrivate && library !== s.getLibrary()) continue;
       Element e = s.lookupLocalMember(memberName);
       if (e === null) continue;
       // Static members are not inherited.
       if (e.modifiers.isStatic()) continue;
       return e;
     }
     return null;
   }
 
   /**
    * Find the first member in the class chain with the given
+   * [memberName] that is accessible from within [library]. If the
+   * [memberName] is not private then the [library] can be `null`.
+   *
+   * This method is NOT to be used for resolving
+   * unqualified sends because it does not implement the scoping
+   * rules, where library scope comes before superclass scope.
+   */
+  Element lookupMemberInLibrary(SourceString memberName,
+                                LibraryElement library) {
+    Element localMember = lookupLocalMember(memberName);
+    if (localMember != null &&
+        (!memberName.isPrivate() || getLibrary() == library)) {
+      return localMember;
+    }
+    return lookupSuperMemberInLibrary(memberName, library);
+  }
+
+  /**
+   * Find the first member in the class chain with the given
    * [memberName]. This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
    * rules, where library scope comes before superclass scope.
    */
   Element lookupMember(SourceString memberName) {
     Element localMember = lookupLocalMember(memberName);
     return localMember === null ? lookupSuperMember(memberName) : localMember;
   }
 
   /**
@@ skipping 343 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, node, type, bound);
     return result;
   }
 }