Perform override and inheritance checks.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 905 matching lines @@
             constConstructors.add(member);
           }
         }
         if (member.isField()) {
           if (!member.modifiers.isStatic() &&
               !member.modifiers.isFinal()) {
             nonFinalInstanceFields.add(member);
           }
         }
         checkAbstractField(member);
-        checkValidOverride(member, cls.lookupSuperMember(member.name));
         checkUserDefinableOperator(member);
       });
     });
     if (!constConstructors.isEmpty && !nonFinalInstanceFields.isEmpty) {
       Spannable span = constConstructors.length > 1
           ? cls : constConstructors[0];
       compiler.reportError(span,
           MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
           {'className': cls.name});
       if (constConstructors.length > 1) {
         for (Element constructor in constConstructors) {
           compiler.reportInfo(constructor,
               MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR);
         }
       }
       for (Element field in nonFinalInstanceFields) {
         compiler.reportInfo(field,
             MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD);
       }
     }
-
-    if (!cls.isAbstract) {
-      for (DartType supertype in cls.allSupertypes) {
-        // This must have been reported elsewhere.
-        if (!supertype.element.isClass()) continue;
-        ClassElement superclass = supertype.element;
-        superclass.forEachMember((ClassElement holder, Element member) {
-          if (member.isAbstract) {
-            Element mine = cls.lookupMember(member.name);
-            if (mine == null || mine.isAbstract) {
-              compiler.reportWarningCode(
-                  cls, MessageKind.UNIMPLEMENTED_METHOD,
-                  {'class_name': cls.name, 'member_name': member.name});
-              compiler.reportHint(member, MessageKind.THIS_IS_THE_METHOD, {});
-            }
-          }
-        });
-      }
-    }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter()) return;
 
     // Find the associated abstract field.
     ClassElement classElement = member.getEnclosingClass();
@@ skipping 132 matching lines @@
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportError(
         errorneousElement,
         errorMessage,
         {'memberName': contextElement.name,
          'className': contextElement.getEnclosingClass().name});
     compiler.reportInfo(contextElement, contextMessage);
   }
 
-  void checkValidOverride(Element member, Element superMember) {
-    if (superMember == null) return;
-    if (member.modifiers.isStatic()) {
-      reportErrorWithContext(
-          member, MessageKind.NO_STATIC_OVERRIDE,
-          superMember, MessageKind.NO_STATIC_OVERRIDE_CONT);
-    } else {
-      FunctionElement superFunction = superMember.asFunctionElement();
-      FunctionElement function = member.asFunctionElement();
-      if (superFunction == null || superFunction.isAccessor()) {
-        // Field or accessor in super.
-        if (function != null && !function.isAccessor()) {
-          // But a plain method in this class.
-          reportErrorWithContext(
-              member, MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
-              superMember, MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
-        }
-      } else {
-        // Instance method in super.
-        if (function == null || function.isAccessor()) {
-          // But a field (or accessor) in this class.
-          reportErrorWithContext(
-              member, MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD,
-              superMember, MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT);
-        } else {
-          // Both are plain instance methods.
-          if (superFunction.requiredParameterCount(compiler) !=
-              function.requiredParameterCount(compiler)) {
-          reportErrorWithContext(
-              member,
-              MessageKind.BAD_ARITY_OVERRIDE,
-              superMember,
-              MessageKind.BAD_ARITY_OVERRIDE_CONT);
-          }
-          // TODO(ahe): Check optional parameters.
-        }
-      }
-    }
-  }
 
   FunctionSignature resolveSignature(FunctionElement element) {
     MessageKind defaultValuesError = null;
     if (element.isFactoryConstructor()) {
       FunctionExpression body = element.parseNode(compiler);
       if (body.isRedirectingFactory) {
         defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
       }
     }
     return compiler.withCurrentElement(element, () {
@@ skipping 3634 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }