Report HintCode.UNUSED_LOCAL_VARIABLE for local variables whose value is never used.

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 3188 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_unusedLocalVariable() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  var v = 1;
+  v = 2;
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isRead_notUsed_compoundAssign() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  var v = 1;
+  v += 2;
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isRead_notUsed_postfixExpr() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  var v = 1;
+  v++;
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isRead_notUsed_prefixExpr() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  var v = 1;
+  ++v;
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isRead_usedArgument() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  var v = 1;
+  print(++v);
+}
+print(x) {}''');
+    resolve(source);
+    assertErrors(source, []);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isRead_usedInvocationTarget() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+class A {
+  foo() {}
+}
+main() {
+  var a = new A();
+  a.foo();
+}
+''');
+    resolve(source);
+    assertErrors(source, []);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_isInvoked() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+typedef Foo();
+main() {
+  Foo foo;
+  foo();
+}''');
+    resolve(source);
+    assertErrors(source, []);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_inCatch_exception() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  try {
+  } catch (exception) {
+  }
+}''');
+    resolve(source);
+    assertErrors(source, []);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_inCatch_stackTrace() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  try {
+  } catch (exception, stackTrace) {
+  }
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
+    verify([source]);
+  }
+
+  void test_unusedLocalVariable_inCatch_stackTrace_used() {
+    enableUnusedLocalVariable = true;
+    Source source = addSource(r'''
+main() {
+  try {
+  } catch (exception, stackTrace) {
+    print('exceptino at $stackTrace');
+  }
+}
+print(x) {}''');
+    resolve(source);
+    assertErrors(source, []);
+    verify([source]);
+  }
+
   void test_useOfVoidResult_assignmentExpression_function() {
     Source source = addSource(r'''
 void f() {}
 class A {
   n() {
     var a;
     a = f();
   }
 }''');
     resolve(source);
@@ skipping 2974 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_LOCAL_VARIABLE].
+   */
+  bool enableUnusedLocalVariable = false;
+
   @override
   void setUp() {
     reset();
   }
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
@@ skipping 22 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) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     for (AnalysisError error in analysisContext2.computeErrors(source)) {
+      if (error.errorCode == HintCode.UNUSED_LOCAL_VARIABLE &&
+          !enableUnusedLocalVariable) {
+        continue;
+      }
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been reported against the given source.
    *
    * @param source the source against which no errors should have been reported
    * @throws AnalysisException if the reported errors could not be computed
@@ skipping 5246 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }