Check that non-abstract classes implement all methods.

dart/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 898 matching lines @@
         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 3819 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);
 }