Make field-get/set work without elements.

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('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 912 matching lines @@
   ClassElement ensureResolved(Compiler compiler) {
     compiler.resolveClass(this);
     return this;
   }
 
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
   Element lookupSuperMember(SourceString memberName) {
+    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;
       Element e = s.lookupLocalMember(memberName);
       if (e === null) continue;
-      // Private members from a different library are not visible.
-      if (memberName.isPrivate() && getLibrary() !== e.getLibrary()) 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]. 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 = localMembers[memberName];
     return localMember === null ? lookupSuperMember(memberName) : localMember;
   }
 
+  /**
+   * Returns true if the [fieldMember] is shadowed by another field. The given
+   * [fieldMember] must be a member of this class.
+   *
+   * This method also works if the [fieldMember] is private.
+   */
+  bool isShadowedByField(Element fieldMember) {
+    assert(fieldMember.isField());
+    // Note that we cannot use [lookupMember] or [lookupSuperMember] since it
+    // will not do the right thing for private elements.
+    ClassElement lookupClass = this;
+    LibraryElement memberLibrary = fieldMember.getLibrary();
+    if (fieldMember.name.isPrivate()) {
+      // We find a super class in the same library as the field. This way the
+      // lookupMember will work.
+      while (lookupClass.getLibrary() != memberLibrary) {
+        lookupClass = lookupClass.superclass;
+      }
+    }
+    SourceString fieldName = fieldMember.name;
+    while (true) {
+      Element foundMember = lookupClass.lookupMember(fieldName);
+      if (foundMember == fieldMember) return false;
+      if (foundMember.isField()) return true;
+      lookupClass = (foundMember.enclosingElement as ClassElement).superclass;
+    }
+  }
+
   Element lookupConstructor(SourceString className,
                             [SourceString constructorName =
                                  const SourceString(''),
                             Element noMatch(Element)]) {
     // 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);
@@ skipping 282 matching lines @@
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }