Report HintCode.UNUSED_ELEMENT for classes.

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 3366 matching lines @@
     if (shortName == null) {
       shortName = displayName;
     }
     Source source = this.source;
     if (source != null) {
       return "$shortName (${source.fullName})";
     }
     return shortName;
   }
 
+  /**
+   * Return `true` if this element is used or potentially can be used.
+   *
+   * For a top-level element: it is public, or it is private and used in the
+   * defining library.
+   *
+   * For a local variable: its value is used (i.e. purely read or invoked)
+   * somewhere in its scope.
+   *
+   * This information is only available for local variables (including
+   * parameters) and only after the compilation unit containing the element
+   * has been resolved.
+   */
+  bool get isUsed {
+    if (isPublic) {
+      return true;
+    }
+    return hasModifier(Modifier.IS_USED_IN_LIBRARY);
+  }
+
   @override
   LibraryElement get library => getAncestor((element) => element is LibraryElement);
 
   @override
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
   @override
   String get name => _name;
 
   @override
@@ skipping 147 matching lines @@
 
   /**
    * Return `true` if this element has the given modifier associated with it.
    *
    * @param modifier the modifier being tested for
    * @return `true` if this element has the given modifier associated with it
    */
   bool hasModifier(Modifier modifier) => BooleanArray.getEnum(_modifiers, modifier);
 
   /**
+   * Specifies that the element is used.
+   */
+  void markUsed() {
+    setModifier(Modifier.IS_USED_IN_LIBRARY, true);
+  }
+
+  /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor to be used to visit the child
    */
   void safelyVisitChild(Element child, ElementVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
@@ skipping 4699 matching lines @@
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   LocalVariableElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   @override
+  bool get isUsed {
+    return hasModifier(Modifier.IS_USED_IN_LIBRARY);
+  }
+
+  @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
   List<ToolkitObjectElement> get toolkitObjects {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return ToolkitObjectElement.EMPTY_ARRAY;
     }
     return unit._getToolkitObjects(this);
   }
 
   @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   bool get isPotentiallyMutatedInClosure => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
 
   @override
   bool get isPotentiallyMutatedInScope => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
 
-  @override
-  bool get isUsed => hasModifier(Modifier.IS_USED_VARIABLE);
-
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
     setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
     setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, true);
   }
 
   /**
-   * Specifies that the value of this variable is used.
-   */
-  void markUsed() {
-    setModifier(Modifier.IS_USED_VARIABLE, true);
-  }
-
-  /**
    * Set the toolkit specific information objects attached to this variable.
    *
    * @param toolkitObjects the toolkit objects attached to this variable
    */
   void set toolkitObjects(List<ToolkitObjectElement> toolkitObjects) {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return;
     }
     unit._setToolkitObjects(this, toolkitObjects);
@@ skipping 440 matching lines @@
    */
   static const Modifier GETTER = const Modifier('GETTER', 8);
 
   /**
    * A flag used for libraries indicating that the defining compilation unit contains at least one
    * import directive whose URI uses the "dart-ext" scheme.
    */
   static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 9);
 
   /**
-   * Indicates that the value of a variable is used - read or invoked.
+   * Indicates that the element is used in the declaring library.
+   *
+   *
+   * For a top-level element: it is public, or it is private and used in the
+   * defining library.
+   *
+   * For a local variable: its value is used (i.e. purely read or invoked)
+   * somewhere in its scope.
    */
-  static const Modifier IS_USED_VARIABLE = const Modifier('IS_USED_VARIABLE', 10);
+  static const Modifier IS_USED_IN_LIBRARY = const Modifier('IS_USED_IN_LIBRARY', 10);
 
   /**
    * Indicates that a class can validly be used as a mixin.
    */
   static const Modifier MIXIN = const Modifier('MIXIN', 11);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated within the context.
    */
   static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT = const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 12);
@@ skipping 35 matching lines @@
       ABSTRACT,
       ASYNCHRONOUS,
       CONST,
       DEFERRED,
       ENUM,
       FACTORY,
       FINAL,
       GENERATOR,
       GETTER,
       HAS_EXT_URI,
-      IS_USED_VARIABLE,
+      IS_USED_IN_LIBRARY,
       MIXIN,
       POTENTIALLY_MUTATED_IN_CONTEXT,
       POTENTIALLY_MUTATED_IN_SCOPE,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
@@ skipping 2762 matching lines @@
   @override
   VariableDeclaration get node => getNodeMatching((node) => node is VariableDeclaration);
 
   @override
   bool get isConst => hasModifier(Modifier.CONST);
 
   @override
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
-   * Return `true` if this variable is used (i.e. purely read or invoked)
-   * somewhere in its scope. This information is only available for local
-   * variables (including parameters) and only after the compilation unit
-   * containing the variable has been resolved.
-   */
-  bool get isUsed => false;
-
-  /**
    * Return `true` if this variable is potentially mutated somewhere in a closure. This
    * information is only available for local variables (including parameters) and only after the
    * compilation unit containing the variable has been resolved.
    *
    * @return `true` if this variable is potentially mutated somewhere in closure
    */
   bool get isPotentiallyMutatedInClosure => false;
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in its scope. This
@@ skipping 159 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }