Report HintCode.UNUSED_ELEMENT for unused methods.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 engine.resolver;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_core.dart';
@@ skipping 15524 matching lines @@
    * identifier is not defined).
    *
    * @return the tag that has the given identifier
    */
   String getTagWithId(String identifier) {
     return idToTagMap[identifier];
   }
 }
 
 
+class _UsedElements {
+  /**
+   * Resolved, locally defined elements that are used or potentially can be
+   * used.
+   */
+  final HashSet<Element> elements = new HashSet<Element>();
+
+  /**
+   * Names of resolved or unresolved class members that are referenced in the
+   * library.
+   */
+  final HashSet<String> members = new HashSet<String>();
+}
+
+
 class _GatherUsedElementsVisitor extends RecursiveAstVisitor {
-  final Set<Element> usedElements = new HashSet<Element>();
+  final _UsedElements usedElements = new _UsedElements();
 
   final LibraryElement _enclosingLibrary;
   ClassElement _enclosingClass;
+  ExecutableElement _enclosingExec;
 
   _GatherUsedElementsVisitor(this._enclosingLibrary);
 
   @override
   visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     _useStaticElement(exceptionParameter);
     super.visitCatchClause(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     ClassElement enclosingClassOld = _enclosingClass;
     try {
       _enclosingClass = node.element;
       super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = enclosingClassOld;
     }
   }
 
   @override
+  visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement enclosingExecOld = _enclosingExec;
+    try {
+      _enclosingExec = node.element;
+      super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingExec = enclosingExecOld;
+    }
+  }
+
+  @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return;
     }
-    Element staticElement = node.staticElement;
-    if (staticElement is LocalVariableElement) {
+    Element element = node.staticElement;
+    if (element is LocalVariableElement) {
       AstNode parent = node.parent;
       if (node.inGetterContext()) {
         if (parent.parent is ExpressionStatement &&
             (parent is PrefixExpression ||
              parent is PostfixExpression ||
              parent is AssignmentExpression && parent.leftHandSide == node)) {
           // v++;
           // ++v;
           // v += 2;
         } else {
-          _useElement(staticElement);
+          _useElement(element);
         }
       }
       if (parent is MethodInvocation && parent.methodName == node) {
-        _useElement(staticElement);
+        _useElement(element);
       }
     } else {
       _useIdentifierElement(node);
+      if (element == null ||
+          element is! LocalElement && !identical(element, _enclosingExec)) {
+        usedElements.members.add(node.name);
+      }
     }
   }
 
   @override
   visitTypeName(TypeName node) {
     _useIdentifierElement(node.name);
   }
 
   /**
    * Marks an [Element] of [node] as used in the library.
    */
   void _useIdentifierElement(Identifier node) {
     Element element = node.staticElement;
     if (element == null) {
       return;
     }
     // check if a local element
     if (!identical(element.library, _enclosingLibrary)) {
       return;
     }
     // ignore references to an element from itself
     if (identical(element, _enclosingClass)) {
       return;
     }
+    if (identical(element, _enclosingExec)) {
+      return;
+    }
     // ignore places where the element is not actually used
     if (node.parent is TypeName) {
       AstNode parent2 = node.parent.parent;
       if (parent2 is IsExpression) {
         return;
       }
       if (parent2 is VariableDeclarationList) {
         return;
       }
     }
     // OK
     _useElement(element);
   }
 
   _useElement(Element element) {
     if (element != null) {
-      usedElements.add(element);
+      usedElements.elements.add(element);
     }
   }
 
   void _useStaticElement(SimpleIdentifier identifier) {
     if (identifier != null) {
       _useElement(identifier.staticElement);
     }
   }
 }
 
 
 /**
  * Instances of the class [_UnusedElementsVerifier] traverse an element
  * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
  * [HintCode.UNUSED_LOCAL_VARIABLE].
  */
 class _UnusedElementsVerifier extends RecursiveElementVisitor {
   /**
    * The error listener to which errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * The elements know to be used.
    */
-  final Set<Element> _usedElements;
+  final _UsedElements _usedElements;
 
   /**
    * Create a new instance of the [_UnusedElementsVerifier].
    */
   _UnusedElementsVerifier(this._errorListener, this._usedElements);
 
   @override
   visitClassElement(ClassElement element) {
-    if (!_isUsed(element)) {
+    if (!_isUsedElement(element)) {
       _reportErrorForElement(
           HintCode.UNUSED_ELEMENT,
           element,
           [element.kind.displayName, element.displayName]);
     }
-    element.visitChildren(this);
+    super.visitClassElement(element);
   }
 
   @override
   visitLocalVariableElement(LocalVariableElement element) {
-    if (!_isUsed(element)) {
+    if (!_isUsedElement(element)) {
       _reportErrorForElement(
           HintCode.UNUSED_LOCAL_VARIABLE,
           element,
           [element.displayName]);
     }
   }
 
-  bool _isUsed(Element element) {
+  @override
+  visitMethodElement(MethodElement element) {
+    if (!_isUsedMember(element)) {
+      _reportErrorForElement(
+          HintCode.UNUSED_ELEMENT,
+          element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitMethodElement(element);
+  }
+
+  bool _isUsedElement(Element element) {
     if (element is! LocalVariableElement) {
       if (element.isPublic) {
         return true;
       }
     }
-    return _usedElements.contains(element);
+    return _usedElements.elements.contains(element);
+  }
+
+  bool _isUsedMember(Element element) {
+    if (element.isPublic) {
+      return true;
+    }
+    if (_usedElements.members.contains(element.displayName)) {
+      return true;
+    }
+    return _usedElements.elements.contains(element);
   }
 
   void _reportErrorForElement(ErrorCode errorCode, Element element, List<Object> arguments) {
     if (element != null) {
       _errorListener.onError(
           new AnalysisError.con2(
               element.source,
               element.nameOffset,
               element.displayName.length,
               errorCode,
               arguments));
     }
   }
 }