New misc-bad-exception-type check.

[sbarzowski]

Summary

It warns about using non-class (or struct) types as an exception. It also blacklists STL smart pointers and std::string.I'm not sure if it's appropriate for mainline as it has very low chance of finding anything in an established, reviewed codebase. I see it more as something to run before the first code review.

Related check: misc-throw-by-value-catch-by-reference
There's a nonempty intersection. For example both checks will warn about throwing a pointer. However misc-throw-by-value-catch-by-reference is more lenient about the exception type (it is happy to allow int, unique_ptr and it explicitly allows string literal). Of course there are also many things that misc-throw-by-value-catch-by-reference handles that are out of scope here.

clang-tidy/misc/BadExceptionTypeCheck.h

+//===--- BadExceptionTypeCheck.h - clang-tidy--------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BAD_EXCEPTION_TYPE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BAD_EXCEPTION_TYPE_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+/// \brief checks for locations that throw an object of inappropriate type.
+/// http://clang.llvm.org/extra/clang-tidy/checks/misc-bad-exception-type.html
+class BadExceptionTypeCheck : public ClangTidyCheck {
+public:
+  BadExceptionTypeCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BAD_EXCEPTION_TYPE_H

clang-tidy/misc/BadExceptionTypeCheck.cpp

+//===--- BadExceptionTypeCheck.cpp - clang-tidy----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "BadExceptionTypeCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+void BadExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+    cxxThrowExpr(has(expr(unless(hasType(cxxRecordDecl(allOf(
+      unless(hasName("::std::basic_string")),
+      unless(hasName("::std::auto_ptr")),
+      unless(hasName("::std::unique_ptr")),
+      unless(hasName("::std::shared_ptr")),
+      unless(hasName("::std::weak_ptr"))
+    )))))))
+    .bind("throw")
+  , this);
+}
+
+void BadExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Throw = Result.Nodes.getNodeAs<CXXThrowExpr>("throw");
+  const auto ExceptionQualType = Throw->getSubExpr()->getType();
+
+  diag(Throw->getLocStart(),
+       "the type of the thrown exception (%0) is not appropriate; "
+       "use a class indicating what happened instead")
+      << ExceptionQualType.getAsString();
+}
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang

clang-tidy/misc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyMiscModule
   ArgumentCommentCheck.cpp
   AssertSideEffectCheck.cpp
+  BadExceptionTypeCheck.cpp
   ForwardingReferenceOverloadCheck.cpp
   MisplacedConstCheck.cpp
   UnconventionalAssignOperatorCheck.cpp
   BoolPointerImplicitConversionCheck.cpp
   DanglingHandleCheck.cpp
   DefinitionsInHeadersCheck.cpp
   FoldInitTypeCheck.cpp
   ForwardDeclarationNamespaceCheck.cpp

clang-tidy/misc/MiscTidyModule.cpp

 //===--- MiscTidyModule.cpp - clang-tidy ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "ArgumentCommentCheck.h"
 #include "AssertSideEffectCheck.h"
+#include "BadExceptionTypeCheck.h"
 #include "BoolPointerImplicitConversionCheck.h"
 #include "DanglingHandleCheck.h"
 #include "DefinitionsInHeadersCheck.h"
 #include "FoldInitTypeCheck.h"
 #include "ForwardDeclarationNamespaceCheck.h"
 #include "ForwardingReferenceOverloadCheck.h"
 #include "InaccurateEraseCheck.h"
 #include "IncorrectRoundings.h"

 namespace misc {
 
 class MiscModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
     CheckFactories.registerCheck<AssertSideEffectCheck>(
         "misc-assert-side-effect");
+    CheckFactories.registerCheck<BadExceptionTypeCheck>(
+        "misc-bad-exception-type");
     CheckFactories.registerCheck<ForwardingReferenceOverloadCheck>(
         "misc-forwarding-reference-overload");
     CheckFactories.registerCheck<MisplacedConstCheck>("misc-misplaced-const");
     CheckFactories.registerCheck<UnconventionalAssignOperatorCheck>(
         "misc-unconventional-assign-operator");
     CheckFactories.registerCheck<BoolPointerImplicitConversionCheck>(
         "misc-bool-pointer-implicit-conversion");
     CheckFactories.registerCheck<DanglingHandleCheck>("misc-dangling-handle");

docs/clang-tidy/checks/list.rst

.. toctree::
    hicpp-use-equals-delete
    hicpp-use-override
    llvm-header-guard
    llvm-include-order
    llvm-namespace-comment
    llvm-twine-local
    misc-argument-comment
    misc-assert-side-effect
+   misc-bad-exception-type
    misc-bool-pointer-implicit-conversion
    misc-dangling-handle
    misc-definitions-in-headers
    misc-fold-init-type
    misc-forward-declaration-namespace
    misc-forwarding-reference-overload
    misc-inaccurate-erase
    misc-incorrect-roundings

docs/clang-tidy/checks/misc-bad-exception-type.rst

+.. title:: clang-tidy - misc-bad-exception-type
+
+misc-bad-exception-type
+=======================
+
+Checks for exceptions of inappropriate type,
+for example string, int or pointer.
+
+It allows only record types and blacklists some types
+from STL. In particular:
+
+* std::string (and std::basic_string<T>)
+* std::auto_ptr
+* std::unique_ptr
+
+See also misc-throw-by-value-catch-by-reference.
+
+Example:
+
+.. code-block:: c++
+
+  throw 42;
+  throw "42";
+  throw std::string("42");

test/clang-tidy/misc-bad-exception-type.cpp

+// RUN: %check_clang_tidy %s misc-bad-exception-type %t
+
+void throw_int() {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (int) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+namespace std {
+  template <typename T>
+  class basic_string {};
+
+  using string = basic_string<char>;
+
+  template <typename T>
+  class auto_ptr {};
+
+  template <typename T>
+  class unique_ptr {};
+
+  template <typename T>
+  class shared_ptr {};
+
+  template <typename T>
+  class weak_ptr {};
+}
+
+
+void throw_string() {
+  throw std::string();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (std::string) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+void throw_auto_ptr() {
+  throw std::auto_ptr<int>();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (std::auto_ptr<int>) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+void throw_unique_ptr() {
+  throw std::unique_ptr<int>();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (std::unique_ptr<int>) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+void throw_shared_ptr() {
+  throw std::shared_ptr<int>();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (std::shared_ptr<int>) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+void throw_weak_ptr() {
+  throw std::weak_ptr<int>();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (std::weak_ptr<int>) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+
+class A{};
+
+void throw_class() {
+  throw A();
+}
+
+void throw_pointer_to_class() {
+  A a;
+  throw &a;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (class A *) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+
+void throw_pointer_to_int() {
+  int x;
+  throw &x;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (int *) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type
+
+void throw_nullptr() {
+  throw nullptr;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: the type of the thrown exception (nullptr_t) is not appropriate; use a class indicating what happened instead [misc-bad-exception-type