Report HintCode.UNUSED_ELEMENT for classes.

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 1903 matching lines @@
  */
 class UnusedLocalVariableVerifier extends RecursiveElementVisitor {
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [UnusedLocalVariableVerifier].
    */
   UnusedLocalVariableVerifier(this._errorReporter);

[Brian Wilkerson, 2014/11/10 23:34:47]

If the class is checking more than local variables we should rename it.

[scheglov, 2014/11/11 02:57:06]

Done.

 
   @override
+  visitClassElement(ClassElement element) {
+    if (element is ClassElementImpl && !element.isUsed) {
+      _errorReporter.reportErrorForElement(
+          HintCode.UNUSED_ELEMENT,
+          element,
+          [element.kind.displayName, element.displayName]);
+    }
+    element.visitChildren(this);
+  }
+
+  @override
   visitLocalVariableElement(LocalVariableElement element) {
     if (element is LocalVariableElementImpl && !element.isUsed) {
       _errorReporter.reportErrorForElement(
           HintCode.UNUSED_LOCAL_VARIABLE,
           element,
           [element.displayName]);
     }
   }
 }
 
@@ skipping 10537 matching lines @@
    */
   final TypeProvider typeProvider;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
+   * The class containing the AST nodes being visited,
+   * or `null` if we are not in the scope of a class.
+   */
+  ClassElement _enclosingClass;
+
+  /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
     this._definingLibrary = library.libraryElement;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
@@ skipping 115 matching lines @@
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     Scope outerScope = _nameScope;
     try {
       if (classElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for class declaration ${node.name.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
         super.visitClassDeclaration(node);
       } else {
-        _nameScope = new TypeParameterScope(_nameScope, classElement);
-        visitClassDeclarationInScope(node);
-        _nameScope = new ClassScope(_nameScope, classElement);
-        visitClassMembersInScope(node);
+        ClassElement outerClass = _enclosingClass;
+        try {
+          _enclosingClass = node.element;
+          _nameScope = new TypeParameterScope(_nameScope, classElement);
+          visitClassDeclarationInScope(node);
+          _nameScope = new ClassScope(_nameScope, classElement);
+          visitClassMembersInScope(node);
+        } finally {
+          _enclosingClass = outerClass;
+        }
       }
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     Scope outerScope = _nameScope;
@@ skipping 2450 matching lines @@
         types.add(type);
       }
     }
     return types;
   }
 
   void _setElement(Identifier typeName, Element element) {
     if (element != null) {
       if (typeName is SimpleIdentifier) {
         typeName.staticElement = element;
+        _markTypeNameElementUsed(typeName, element);
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName;
         identifier.identifier.staticElement = element;
         SimpleIdentifier prefix = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix, definingLibrary);
         if (prefixElement != null) {
           prefix.staticElement = prefixElement;
         }
       }
     }
   }
 
   /**
+   * Marks [element] as used in its defining library.
+   */
+  void _markTypeNameElementUsed(Identifier typeName, Element element) {
+    if (identical(element, _enclosingClass)) {
+      return;
+    }
+    // ignore places where the element is not actually used
+    if (typeName.parent is TypeName) {
+      AstNode parent2 = typeName.parent.parent;
+      if (parent2 is IsExpression) {
+        return;
+      }
+      if (parent2 is VariableDeclarationList) {
+        return;
+      }
+    }
+    // check if the element is a local top-level element
+    if (element is ElementImpl &&
+        element.enclosingElement is CompilationUnitElement &&
+        identical(element.library, definingLibrary)) {
+      element.markUsed();
+    }
+  }
+
+  /**
    * Given a parameter element, create a function type based on the given return type and parameter
    * list and associate the created type with the element.
    *
    * @param element the parameter element whose type is to be set
    * @param returnType the (possibly `null`) return type of the function
    * @param parameterList the list of parameters to the function
    */
   void _setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType, FormalParameterList parameterList) {
     List<ParameterElement> parameters = _getElements(parameterList);
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl.forNode(null);
@@ skipping 411 matching lines @@
   /**
    * Return the tag that has the given identifier, or {@code null} if there is no such tag (the
    * identifier is not defined).
    *
    * @return the tag that has the given identifier
    */
   String getTagWithId(String identifier) {
     return idToTagMap[identifier];
   }
 }