Implement override checks.

dart/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 198 matching lines @@
       String holderName = enclosingElement.name.slowToString();
       return '$kind($holderName#${name.slowToString()})';
     } else {
       return '$kind(${name.slowToString()})';
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
+
+  FunctionElement asFunctionElement() => null;
 }
 
 class ContainerElement extends Element {
   ContainerElement(name, kind, enclosingElement) :
     super(name, kind, enclosingElement);
 
   abstract void addMember(Element element, DiagnosticListener listener);
 
   void addGetterOrSetter(Element element,
                          Element existing,
@@ skipping 16 matching lines @@
           field.getter = element;
         } else {
           if (field.setter != null && field.setter != element) {
             reportError(field.setter);
           }
           field.setter = element;
         }
       }
     } else {
       AbstractFieldElement field = new AbstractFieldElement(element.name, this);
-      addMember(field, listener);
       if (element.kind == ElementKind.GETTER) {
         field.getter = element;
       } else {
         field.setter = element;
       }
+      addMember(field, listener);
     }
   }
 }
 
 class CompilationUnitElement extends ContainerElement {
   final Script script;
   Link<Element> topLevelElements = const EmptyLink<Element>();
 
   CompilationUnitElement(Script script, Element enclosing)
     : this.script = script,
@@ skipping 224 matching lines @@
   }
 
   parseNode(DiagnosticListener listener) {
     throw "internal error: ForeignElement has no node";
   }
 }
 
 class AbstractFieldElement extends Element {
   FunctionElement getter;
   FunctionElement setter;
-  Modifiers modifiers;
 
   AbstractFieldElement(SourceString name, Element enclosing)
-      : super(name, ElementKind.ABSTRACT_FIELD, enclosing),
-        modifiers = new Modifiers.empty();
+      : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   Type computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
   }
 
   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 && getter.enclosingElement === enclosingElement) {
       return getter.position();
-    } else if (setter != null) {
-      // TODO(ahe): checking for null should not be necessary.
+    } else {
       return setter.position();
     }
   }
+
+  Modifiers get modifiers() {
+    // The resolver ensures that the flags match (ignoring abstract).
+    if (getter !== null) {
+      return new Modifiers.withFlags(
+          getter.modifiers.nodes,
+          getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
+    } else {
+      return new Modifiers.withFlags(
+          setter.modifiers.nodes,
+          setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
+    }
+  }
 }
 
 class FunctionSignature {
   Link<Element> requiredParameters;
   Link<Element> optionalParameters;
   Type returnType;
   int requiredParameterCount;
   int optionalParameterCount;
   FunctionSignature(this.requiredParameters,
                     this.optionalParameters,
@@ skipping 91 matching lines @@
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     type = compiler.computeFunctionType(this, computeSignature(compiler));
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) => cachedNode;
 
   Token position() => cachedNode.getBeginToken();
+
+  FunctionElement asFunctionElement() => this;
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               null,
@@ skipping 73 matching lines @@
   }
 
   Type computeType(compiler) {
     if (type === null) {
       type = new InterfaceType(this);
     }
     return type;
   }
 
   ClassElement ensureResolved(Compiler compiler) {
-    if (!isResolved && !isBeingResolved) {
-      isBeingResolved = true;
-      compiler.resolveClass(this);
-      isBeingResolved = false;
-      isResolved = true;
-    }
+    compiler.resolveClass(this);
     return this;
   }
 
   Element lookupTypeParameter(SourceString parameterName) {
     Element result = typeParameters[parameterName];
     return result;
   }
 
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
   Element lookupSuperMember(SourceString memberName) {
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       Element e = s.lookupLocalMember(memberName);
-      if (e !== null) {
-        if (!memberName.isPrivate() || getLibrary() === e.getLibrary()) {
-          return e;
-        }
-      }
+      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.
    */
@@ skipping 290 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }