Collect defined elements together with used elements.

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 3983 matching lines @@
     for (int i = 0; i < count; i++) {
       annotations[i].accept(this);
     }
   }
 }
 
 /**
  * An [AstVisitor] that fills [UsedLocalElements].
  */
 class GatherUsedLocalElementsVisitor extends RecursiveAstVisitor {
+  final List<Element> definedElements = <Element>[];
   final UsedLocalElements usedElements = new UsedLocalElements();
 
   final LibraryElement _enclosingLibrary;
   ClassElement _enclosingClass;
   ExecutableElement _enclosingExec;
 
   GatherUsedLocalElementsVisitor(this._enclosingLibrary);
 
   @override
   visitCatchClause(CatchClause node) {
@@ skipping 49 matching lines @@
     try {
       _enclosingExec = node.element;
       super.visitMethodDeclaration(node);
     } finally {
       _enclosingExec = enclosingExecOld;
     }
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
+    Element element = node.staticElement;
     if (node.inDeclarationContext()) {
+      definedElements.add(element);
       return;
     }
-    Element element = node.staticElement;
     bool isIdentifierRead = _isReadIdentifier(node);
     if (element is LocalVariableElement) {
       if (isIdentifierRead) {
         usedElements.addElement(element);
       }
     } else {
       _useIdentifierElement(node);
       if (element == null ||
           element.enclosingElement is ClassElement &&
               !identical(element, _enclosingExec)) {
@@ skipping 8054 matching lines @@
     }
     return false;
   }
 }
 
 /**
  * Instances of the class [UnusedLocalElementsVerifier] traverse an element
  * structure looking for cases of [HintCode.UNUSED_ELEMENT],
  * [HintCode.UNUSED_FIELD], [HintCode.UNUSED_LOCAL_VARIABLE], etc.
  */
-class UnusedLocalElementsVerifier extends RecursiveElementVisitor {
+class UnusedLocalElementsVerifier extends SimpleElementVisitor {
   /**
    * The error listener to which errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * The elements know to be used.
    */
   final UsedLocalElements _usedElements;
 
   /**
    * Create a new instance of the [UnusedLocalElementsVerifier].
    */
   UnusedLocalElementsVerifier(this._errorListener, this._usedElements);
 
   @override
   visitClassElement(ClassElement element) {
     if (!_isUsedElement(element)) {
       _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
           [element.kind.displayName, element.displayName]);
     }
     super.visitClassElement(element);
   }
 
+  visitElement(Element element) {

[Paul Berry, 2016/02/09 20:34:25]

Why not simply:

    element.accept(this);

Or better yet, do it at the call site and then you don't need this method at
all.

[Brian Wilkerson, 2016/02/09 20:35:57]

I was about to make the same comment. After all, one point of a visitor pattern
is to avoid this kind of 'is' test.

+    if (element is ClassElement) {
+      visitClassElement(element);
+    } else if (element is FieldElement) {
+      visitFieldElement(element);
+    } else if (element is FunctionElement) {
+      visitFunctionElement(element);
+    } else if (element is FunctionTypeAliasElement) {
+      visitFunctionTypeAliasElement(element);
+    } else if (element is LocalVariableElement) {
+      visitLocalVariableElement(element);
+    } else if (element is MethodElement) {
+      visitMethodElement(element);
+    } else if (element is PropertyAccessorElement) {
+      visitPropertyAccessorElement(element);
+    }
+  }
+
   @override
   visitFieldElement(FieldElement element) {
     if (!_isReadMember(element)) {
       _reportErrorForElement(
           HintCode.UNUSED_FIELD, element, [element.displayName]);
     }
     super.visitFieldElement(element);
   }
 
   @override
@@ skipping 494 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }