Report HintCode.UNUSED_ELEMENT for classes.

pkg/analyzer/lib/src/generated/element_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.element_resolver;
 
 import 'dart:collection';
 
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 1013 matching lines @@
       if (_isConstructorReturnType(node)) {
         _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
         _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       } else {
         _recordUndefinedNode(_resolver.enclosingClass, StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
+    _markElementUsed(element);
     if (node.inSetterContext() && node.inGetterContext() && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(_lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
     //
     // Validate annotation element.
     //
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
@@ skipping 851 matching lines @@
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpSetterInInterfaces(superclass, true, setterName, visitedInterfaces);
   }
 
   /**
+   * Marks [element] as used in its defining library.
+   */
+  void _markElementUsed(Element element) {

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

This seems overly complex. Would it be sufficient to only check that the library
is the same? If so, would it be less efficient?

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

Done.

+    if (identical(element, _resolver.enclosingClass)) {
+      return;
+    }
+    if (element is ElementImpl &&
+        element.enclosingElement is CompilationUnitElement &&
+        identical(element.library, _definingLibrary)) {
+      element.markUsed();
+    }
+  }
+
+  /**
    * Given some class element, this method uses [subtypeManager] to find the set of all
    * subtypes; the subtypes are then searched for a member (method, getter, or setter), that matches
    * a passed
    *
    * @param element the class element to search the subtypes of, if a non-ClassElement element is
    *          passed, then `false` is returned
    * @param memberName the member name to search for
    * @param asMethod `true` if the methods should be searched for in the subtypes
    * @param asAccessor `true` if the accessors (getters and setters) should be searched for in
    *          the subtypes
@@ skipping 731 matching lines @@
   @override
   Element get propagatedElement => null;
 
   @override
   Element get staticElement => null;
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 }