Report HintCode.UNUSED_ELEMENT for classes.

pkg/analyzer/test/generated/resolver_test.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_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
@@ skipping 3190 matching lines @@
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 class B {}''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
+  void test_unusedElement_class_noReference() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+main() {
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_ELEMENT]);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_inConstructorName() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {
+  _A() {}
+  _A.named() {}
+}
+''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_ELEMENT]);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_inClassMember() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {
+  static staticMethod() {
+    new _A();
+  }
+  instanceMethod() {
+    new _A();
+  }
+}
+''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_ELEMENT]);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isExpression() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+main(p) {
+  if (p is _A) {
+  }
+}
+''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_ELEMENT]);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_variableDeclaration() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+main() {
+  _A v;
+  print(v);
+}
+print(x) {}
+''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_ELEMENT]);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isUsed_extends() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+class B extends _A {}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isUsed_implements() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+class B implements _A {}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isUsed_instanceCreation() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {}
+main() {
+  new _A();
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isUsed_staticFieldAccess() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {
+  static const F = 42;
+}
+main() {
+  _A.F;
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_unusedElement_class_isUsed_staticMethodInvocation() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class _A {
+  static m() {}
+}
+main() {
+  _A.m();
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_unusedLocalVariable() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   v = 2;
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
@@ skipping 3106 matching lines @@
   }
 }
 
 class ResolverTestCase extends EngineTestCase {
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
   AnalysisContextImpl analysisContext2;
 
   /**
+   * Specifies if [assertErrors] should check for [HintCode.UNUSED_ELEMENT].
+   */
+  bool enableUnusedElement = false;
+
+  /**
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_LOCAL_VARIABLE].
    */
   bool enableUnusedLocalVariable = false;
 
   @override
   void setUp() {
     reset();
   }
 
   /**
@@ skipping 26 matching lines @@
    *
    * @param source the source against which the errors should have been reported
    * @param expectedErrorCodes the error codes of the errors that should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if a different number of errors have been reported than were
    *           expected
    */
   void assertErrors(Source source, [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     for (AnalysisError error in analysisContext2.computeErrors(source)) {
+      if (error.errorCode == HintCode.UNUSED_ELEMENT &&
+          !enableUnusedElement) {
+        continue;
+      }
       if (error.errorCode == HintCode.UNUSED_LOCAL_VARIABLE &&
           !enableUnusedLocalVariable) {
         continue;
       }
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   /**
@@ skipping 5362 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }