Lint for `@mustCallSuper` (#194).

lib/src/rules/must_call_super.dart

 // Copyright (c) 2016, 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 linter.src.rules.annotate_overrides;
+library linter.src.rules.must_call_super;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:linter/src/linter.dart';
 
-const desc = r'Annotate overridden members';
+const desc = r'Methods marked @mustCallSuper must invoke super';
 
 const details = r'''
-**DO** annotate overridden methods and fields.
+Methods marked `@mustCallSuper` must invoke the overriden super method.
+
+**DO** ensure that all methods that override a method with the `@mustCallSuper`
+annotation contain a super invocation of the overridden method.
+
+The `@mustCallSuper` annotation is implemented in the `meta`
+[package](https://pub.dartlang.org/packages/meta).
+
+**BAD:**
+```
+class TestCase {
+  @mustCallSuper
+  void setUp() { ... }
+}
+
+class MyTest extends TestCase {
+  @override
+  void setUp() {
+    // do nothing.
+  }
+  ...
+}
+```
 
 **GOOD:**
 ```
-abstract class Dog {
-  String get breed;
-  void bark() {}
+class TestCase {
+  @mustCallSuper
+  void setUp() { ... }
 }
 
-class Husky extends Dog {
+class MyTest extends TestCase {
   @override
-  final String breed = 'Husky';
-  @override
-  void bark() {}
+  void setUp() {
+    super.setUp();
+  }
 }
 ```
 
-**BAD:**
-```
-class Cat {
-  int get lives => 9;
+''';
+
+class InvocationCollector extends RecursiveAstVisitor {
+  final List<String> superCalls = <String>[];
+
+  @override
+  visitMethodInvocation(MethodInvocation node) {
+    if (node.target is SuperExpression) {
+      superCalls.add(node.methodName.name);
+    }
+  }
 }
 
-class Lucky extends Cat {
-  final int lives = 14;
-}
-```
-''';
-
-class AnnotateOverrides extends LintRule {
-  AnnotateOverrides()
+class MustCallSuper extends LintRule {
+  MustCallSuper()
       : super(
-            name: 'annotate_overrides',
+            name: 'must_call_super',
             description: desc,
             details: details,
             group: Group.style);
 
   @override
   AstVisitor getVisitor() => new Visitor(this);
 }
 
 class Visitor extends SimpleAstVisitor {
   InheritanceManager manager;
@@ skipping 14 matching lines @@
     return manager.lookupInheritance(classElement, member.name);
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     LibraryElement library = node?.element?.library;
     manager = library == null ? null : new InheritanceManager(library);
   }
 
   @override
-  visitFieldDeclaration(FieldDeclaration node) {
-    for (VariableDeclaration field in node.fields.variables) {
-      if (field?.element != null && !field.element.isOverride) {
-        ExecutableElement member = getOverriddenMember(field.element);
-        if (member != null) {
-          rule.reportLint(field);
-        }
-      }
-    }
-  }
-
-  @override
   visitMethodDeclaration(MethodDeclaration node) {
-    if (node?.element != null && !node.element.isOverride) {
-      ExecutableElement member = getOverriddenMember(node.element);
-      if (member != null) {
+    ExecutableElement overriddenMember = getOverriddenMember(node.element);
+    if (overriddenMember != null) {
+      InvocationCollector collector = new InvocationCollector();
+      node.accept(collector);
+      if (!collector.superCalls.contains(overriddenMember.name)) {
         rule.reportLint(node.name);
       }
     }
   }
 }