Report separate UNUSED_CATCH_CLAUSE and UNUSED_CATCH_STACK hints.

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:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 14938 matching lines @@
 
   final LibraryElement _enclosingLibrary;
   ClassElement _enclosingClass;
   ExecutableElement _enclosingExec;
 
   _GatherUsedElementsVisitor(this._enclosingLibrary);
 
   @override
   visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
-    _useStaticElement(exceptionParameter);
+    SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+    if (exceptionParameter != null) {
+      Element element = exceptionParameter.staticElement;
+      usedElements.addCatchException(element);
+      if (stackTraceParameter != null || node.onKeyword == null) {
+        _useElement(element);
+      }
+    }
+    if (stackTraceParameter != null) {
+      Element element = stackTraceParameter.staticElement;
+      usedElements.addCatchStackTrace(element);
+    }
     super.visitCatchClause(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     ClassElement enclosingClassOld = _enclosingClass;
     try {
       _enclosingClass = node.element;
       super.visitClassDeclaration(node);
     } finally {
@@ skipping 108 matching lines @@
         return;
       }
       if (parent2 is VariableDeclarationList) {
         return;
       }
     }
     // OK
     _useElement(element);
   }
 
-  void _useStaticElement(SimpleIdentifier identifier) {
-    if (identifier != null) {
-      _useElement(identifier.staticElement);
-    }
-  }
-
   static bool _isReadIdentifier(SimpleIdentifier node) {
     // not reading at all
     if (!node.inGetterContext()) {
       return false;
     }
     // check if useless reading
     AstNode parent = node.parent;
     if (parent.parent is ExpressionStatement &&
         (parent is PrefixExpression ||
             parent is PostfixExpression ||
@@ skipping 146 matching lines @@
         element.kind.displayName,
         element.displayName
       ]);
     }
     super.visitFunctionElement(element);
   }
 
   @override
   visitLocalVariableElement(LocalVariableElement element) {
     if (!_isUsedElement(element)) {
-      _reportErrorForElement(
-          HintCode.UNUSED_LOCAL_VARIABLE, element, [element.displayName]);
+      HintCode errorCode;
+      if (_usedElements.isCatchException(element)) {
+        errorCode = HintCode.UNUSED_CATCH_CLAUSE;
+      } else if (_usedElements.isCatchStackTrace(element)) {
+        errorCode = HintCode.UNUSED_CATCH_STACK;
+      } else {
+        errorCode = HintCode.UNUSED_LOCAL_VARIABLE;
+      }
+      _reportErrorForElement(errorCode, element, [element.displayName]);
     }
   }
 
   @override
   visitMethodElement(MethodElement element) {
     if (!_isUsedMember(element)) {
       _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
         element.kind.displayName,
         element.displayName
       ]);
@@ skipping 61 matching lines @@
 }
 
 class _UsedElements {
   /**
    * Resolved, locally defined elements that are used or potentially can be
    * used.
    */
   final HashSet<Element> elements = new HashSet<Element>();
 
   /**
+   * [LocalVariableElement]s that represent exceptions in [CatchClause]s.
+   */
+  final HashSet<LocalVariableElement> catchExceptionElements =
+      new HashSet<LocalVariableElement>();
+
+  /**
+   * [LocalVariableElement]s that represent stack traces in [CatchClause]s.
+   */
+  final HashSet<LocalVariableElement> catchStackTraceElements =
+      new HashSet<LocalVariableElement>();
+
+  /**
    * Names of resolved or unresolved class members that are referenced in the
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
+
+  void addCatchException(LocalVariableElement element) {
+    if (element != null) {
+      catchExceptionElements.add(element);
+    }
+  }
+
+  void addCatchStackTrace(LocalVariableElement element) {
+    if (element != null) {
+      catchStackTraceElements.add(element);
+    }
+  }
+
+  bool isCatchException(LocalVariableElement element) {
+    return catchExceptionElements.contains(element);
+  }
+
+  bool isCatchStackTrace(LocalVariableElement element) {
+    return catchStackTraceElements.contains(element);
+  }
 }