[clang-tidy] misc-throw-with-noexcept

[sbarzowski]

Summary

New check that warns about throw in noexcept function.

[Eugene.Zelenko]

Please add documentation and mention this check in docs/clang-tidy/checks/list.rst and docs/ReleaseNotes.rst (in alphabetical order).

[Prazek]

Do you know guys is it possible to get to noexcept source location, or we have to do by hand using lexer?

[alexfh]

In D19201#403585, @Prazek wrote:

Do you know guys is it possible to get to noexcept source location, or we have to do by hand using lexer?

If it might be possible to get the location of noexcept(expression) using FunctionProtoType::getNoExceptExpr (though I haven't tried this), but there seems to be no information left in the AST about a simple noexcept. However, it should be easy to find noexcept using a lexer (unless, it's hidden in a macro).

[alexfh]

Please fix formatting, btw.

[sbarzowski]

Note `FunctionProtoType::getNoExceptExpr` is weird. If you have the same expr in multiple noexcepts, then it returns the same object for all of them, so it is useless for determining the location in code.

I ended up finding it all "by hand" with lexer (looking for matching parentheses).

[aaron.ballman]

In D19201#445406, @sbarzowski wrote:

Note `FunctionProtoType::getNoExceptExpr` is weird. If you have the same expr in multiple noexcepts, then it returns the same object for all of them, so it is useless for determining the location in code.

I ended up finding it all "by hand" with lexer (looking for matching parentheses).

I think you may want to take a dependency on: http://reviews.llvm.org/D20428

[Prazek]

In D19201#445496, @aaron.ballman wrote:

In D19201#445406, @sbarzowski wrote:

Note `FunctionProtoType::getNoExceptExpr` is weird. If you have the same expr in multiple noexcepts, then it returns the same object for all of them, so it is useless for determining the location in code.

I ended up finding it all "by hand" with lexer (looking for matching parentheses).

I think you may want to take a dependency on: http://reviews.llvm.org/D20428

We will see how much time it will take to make it pushable to master. IMHO this code is not complicated enough to make it wait for your patch, but it's cool that you took care of it :)

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

26

you can use forFunction instead of hasAncestor(functionDecl(
cxxThrowExpr(stmt(forFunction(isNoThrow() or cxxThrowExpr(stmt(forFunction(functionDecl(isNoThrow())))
you can even try to remove stmt.

Also add test case

void getFunction() noexcept {
 struct X { 
  static void inner()
  {
      throw 42;
  }
 }; 
}

131

add new line after this line

132

add some new line

135

if one one the redecl won't be valid, then you can't change any of them. I guess you should accumulate them in
llvm::SmallVector<SourseRange, 5> whilie checking if they are valid. If all of them will be valid then perform fix on all of them.

136

I think it would be better to tell about declaration only in one place (where is the definition)

Also, I would use "note:" instead of warning here. (passing DiagnosticIDs::Level::Note as third argument)
You can also see how to do it here:
http://reviews.llvm.org/D18821

Also I think "no-throw function declared here" would be better

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

33

function in llvm starts with lower case

58

same here

72

move it one line higher

74

Use full words. Consider changit to OpenParenCount

92

rename it to findNoexceptRange at mark it static.

103

remove extra braces

109–111

The comment is wrong. Shouldn't it be // We have noexcept that doesn't evaluate to true

[aaron.ballman]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

26

Hmm, I wonder if it's trivial enough to filter out throw statements that are inside a try block scope (even without checking the expression and catch block types)?

33

I prefer this be gated on D20428; we should be pushing this functionality down where it belongs instead of replicating it in several different clang-tidy checks.

92

This function will not work with dynamic exception specifications that also specify the function is nonthrowing, e.g., throw().

131

How about wording the diagnostic: "'throw' expression in a function declared with a non-throwing exception specification"

132

const auto *, please (assuming Redecl is a pointer type).

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

What is the false positive rate with this check over a large codebase that uses exceptions?

test/clang-tidy/misc-throw-with-noexcept.cpp

71

There are no tests for dynamic exception specifications.

[sbarzowski]

Thanks for review, guys. I fixed as many easy problems as I had time for today, will continue later.

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

26

unless(hasAncestor(cxxTryStmt())) should do the work for almost all cases.
Maybe even something like this to catch only valid try blocks

cxxThrowExpr(stmt(forFunction(functionDecl(isNoThrow()).bind("func"))),
unless(hasAncestor(cxxTryStmt().bind("try"), forFunction(hasBody(hasDescendant(equalsBoundNode("try")))))

+ it should check that the throw is not in CXXCatchStmt (unless it is in another try block).

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

34

I agree 100%. I see the code here as a temporary solution, before we have a proper AST functionality for doing that cleanly.

[alexfh]

Removing from my dashboard until D20428 is submitted.

[sbarzowski]

I took advantage of new getExceptionSpecSourceRange (it wasn't available before) instead of getting exception specification manually with the lexer.

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

53–54

just add DiagnosticIDs::Note as third argument
This might also change the order of diagnostics as we discussed ofline

[alexfh]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

45

Use line comments (//).

54

nit: no leading capitalization in diagnostic messages needed.

test/clang-tidy/misc-throw-with-noexcept.cpp

89

Please add test cases where the function in question is a template itself (and another one where it's a member of a template class) and has a few instantiations.

[sbarzowski]

Improved messages, added tests with templates, fixed some typos.

[alexfh]

A couple of nits. Please address Aaron's comment as well.

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

53

nit: remove the FIXME

54

nit: nothrow (without a dash), no colon needed (it will look weird, since the location is mentioned _before_ the message, not after it)

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

No, it's after the message now. When I changed the level to note the order of messages changed as well.

It looks like that:

/Users/uland/clang-new/build/tools/clang/tools/extra/test/clang-tidy/Output/misc-throw-with-noexcept.cpp.tmp.cpp:5:5: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
    throw 5;
    ^
/Users/uland/clang-new/build/tools/clang/tools/extra/test/clang-tidy/Output/misc-throw-with-noexcept.cpp.tmp.cpp:3:24: note: FIX-IT applied suggested code changes
void f_throw_with_ne() noexcept(true) {
                       ^
/Users/uland/clang-new/build/tools/clang/tools/extra/test/clang-tidy/Output/misc-throw-with-noexcept.cpp.tmp.cpp:3:24: note: in a function declared nothrow here:
void f_throw_with_ne() noexcept(true) {
                       ^

So, should I leave the colon or remove it anyway?

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

I think that the best way would be to have warnings in order:

warning function declared nothrow here have throw statement inside:
Note: throw statement here

Note: Fixit applied for every other declaration

What do you think Alex?

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

@Prazek
So, do you suggest that we don't emit anything for additional declarations (without -fix)?

BTW (in the current version) I don't know if I can control if FIX-IT goes first or the location message. As you can see in the code the FIX-IT goes after the location.

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

Yep, there is no need for user to know all the locations if he doesn't want to perform fixit. This way it is easier to read the warning.

[alexfh]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

The FIX-IT applied suggested code changes notes are shown by clang-tidy itself and only when the user passes -fix flag. There's no way to control them from the check (apart from removing fixes or attaching them to a different warning).

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

54

That's right, but does it make sense to show user all the places where the function was declared?
I am not sure what clang would normally do

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

Do you know any good project to check it?

[vmiklos]

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

LibreOffice might be a candidate, see https://wiki.documentfoundation.org/Development/ClangTidy for details on how to generate a compile database for it (since it does not use cmake), then you can start testing.

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

Thanks. However it's not just about using exception. To be meaningful I need a project that use noexcept in more than a few places.

Here are some projects that I found:
https://github.com/facebook/hhvm/search?utf8=%E2%9C%93&q=noexcept
https://github.com/facebook/folly/search?utf8=%E2%9C%93&q=noexcept
https://github.com/Tencent/mars/search?utf8=%E2%9C%93&q=noexcept
https://github.com/facebook/rocksdb/search?utf8=%E2%9C%93&q=noexcept
https://github.com/CRYTEK-CRYENGINE/CRYENGINE/search?utf8=%E2%9C%93&q=noexcept
https://github.com/SFTtech/openage/search?utf8=%E2%9C%93&q=noexcept
https://github.com/facebook/watchman/search?utf8=%E2%9C%93&q=noexcept
https://github.com/facebook/proxygen/search?utf8=%E2%9C%93&q=noexcept
https://github.com/philsquared/Catch/search?utf8=%E2%9C%93&q=noexcept
https://github.com/sandstorm-io/capnproto/search?utf8=%E2%9C%93&q=noexcept
https://github.com/miloyip/rapidjson/search?utf8=%E2%9C%93&q=noexcept

I've tried HHVM so far, and ran into some problems compiling it. Anyway I'm working on it.

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

Ok, I was able to run it on most of the HHVM codebase + deps. There were some issues that looked like some autogenerated pieces missing, so it may have been not 100% covered.

The results:
3 occurences in total

1. rethrow in destructor (http://pastebin.com/JRNMZGev)
2. false positive "throw and catch in the same function" (http://pastebin.com/14y1AJgM)
3. noexcept decided during compilation (http://pastebin.com/1jZzRAbC)

That's not too many, but this is a kind of check that I guess would be most useful earlier in the development - ideally before the initial code review.

I'm not sure if we should count (3) as false positive. We could potentially eliminate it, by checking if the expression in noexcept is empty or true literal.

(2) is def. a false positive. The potential handling of this case was already proposed, but I'm not sure if it's worth it. The code in example (2) is ugly and extracting these throwing parts to separate functions looks like a good way to start refactoring.

What do you think?

[aaron.ballman]

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

The fact that there's a false positive in the first large project you checked suggests that the false positive is likely worth it to fix. The code may be ugly, but it's not uncommon -- some coding guidelines explicitly disallow use of gotos, and this is a reasonable(ish) workaround for that.

As for #3, I would consider that to be a false-positive as well. A computed noexcept clause is going to be very common, especially in generic code. I think it's probably more important to get this one right than #2.

[sbarzowski]

Fixed false positive issues

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

23

If we handle throw() then it should be CPlusPlus

29

is this cland-formatted?

52–54

Here and in many other places - remove unnecessary braces (llvm coding style)

118

clang-format whole file

docs/clang-tidy/checks/misc-throw-with-noexcept.rst

10–11

This is probably outdated. Also mention the other features that you developed here.

[sbarzowski]

Docs and cosmetic issues

[sbarzowski]

Removed unnecessary colon from message

[Prazek]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

77

unnecessary braces

114–116

unnecessary braces

127–132

same here

[Prazek]

docs/ReleaseNotes.rst

60

I think this should be in alphabetical order.

[aaron.ballman]

As an FYI, there is a related check being implemented in clang currently; we probably should not duplicate this effort. See https://reviews.llvm.org/D33333.

[sbarzowski]

Cosmetic

[sbarzowski]

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

26

Now even the caught type is checked.

clang-tidy/misc/ThrowWithNoexceptCheck.h

21

I have fixed these issues.

[Prazek]

In D19201#760151, @aaron.ballman wrote:

As an FYI, there is a related check being implemented in clang currently; we probably should not duplicate this effort. See https://reviews.llvm.org/D33333.

I think that clang is the right place for this feature, but I am not sure if the patch has all the features (like checking if something will be catched, or not showing warning for conditional noexcepts, which as we have seen
could be a problem for some projects. There also might be some other corner cases that we didn't think about.
Assuming that this patch is ready to land, I would propose to send it to trunk and remove it when the clang's patch will make it to the trunk. I am not sure how much time it will take for other patch to be ready, but maybe we could gather some usefull bug reports in the meantime and also Stanislaw would have a contribution.

[Prazek]

LGTM, but wait if Aaron will accept it.

[aaron.ballman]

In D19201#760358, @Prazek wrote:

In D19201#760151, @aaron.ballman wrote:

As an FYI, there is a related check being implemented in clang currently; we probably should not duplicate this effort. See https://reviews.llvm.org/D33333.

I think that clang is the right place for this feature, but I am not sure if the patch has all the features (like checking if something will be catched, or not showing warning for conditional noexcepts, which as we have seen
could be a problem for some projects. There also might be some other corner cases that we didn't think about.
Assuming that this patch is ready to land, I would propose to send it to trunk and remove it when the clang's patch will make it to the trunk. I am not sure how much time it will take for other patch to be ready, but maybe we could gather some usefull bug reports in the meantime and also Stanislaw would have a contribution.

I don't think it's a good idea to commit this and remove it when the frontend patch lands -- that's just extra code churn and runs the risk of breaking people who are using features out of trunk. I think the better approach is to find the correct home for the functionality based on what *both* patches are trying to accomplish, and combine the test cases from both patches to ensure we get the desired functionality. The two patches appear to be almost entirely overlapping, from my cursory look (of course, I may have missed something).

I think that the frontend is likely the better place for this functionality to go in terms of where users might expect to find it, assuming the false-positive rate is reasonable and it isn't too computationally expensive. My recommendation would be to find the test cases in this patch that are not currently covered by the frontend patch, and ask that they be covered there (possibly even including the fixits).

[baloghadamsoftware]

There is a patch (D33537) for a check which is a superset of this: It does not only check for noexcept (and throw()) functions, but also for destructors, move constructors, move assignments, the main() function, swap() functions and also functions given as option. A more important difference is that we traverse the whole call-chain and check all the throw statements and try-catch blocks so indirectly throwing functions are also reported and no flase positives are caused by throw and catch in the same try block.

[sbarzowski]

In D19201#768693, @baloghadamsoftware wrote:

There is a patch (D33537) for a check which is a superset of this: [...] A more important difference is that we traverse the whole call-chain and check all the throw statements and try-catch blocks so indirectly throwing functions are also reported and no flase positives are caused by throw and catch in the same try block.

As a matter of fact this check also handles catching, so no false positive here.

But let's get to the point:
For me D33537 and D33333 seem like clearly better options and I think we should proceed with one or both of them instead of this one. However they don't handle (yet) everything that this check does. In particular they don't seem to handle noexcept decided during compilation (example: https://pastebin.com/1jZzRAbC). I've run into this case when I tried this check on HHVM and its dependencies.

Quoting @aaron.ballman

As for #3 [noexcept decided during compilation], I would consider that to be a false-positive as well. A computed noexcept clause is going to be very common, especially in generic code. I think it's probably more important to get this one right than #2 [throw and catch in the same function].

As for this check, I think the development will stop here, no point in duplicating the effort. Maybe the test cases will be of some use to you.

[shafik]

Is this PR still relevant or can we close it?

clang-tidy/misc/CMakeLists.txt

add_clang_library(clangTidyMiscModule
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousMissingCommaCheck.cpp
   SuspiciousSemicolonCheck.cpp
   SuspiciousStringCompareCheck.cpp
   SwappedArgumentsCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp
+  ThrowWithNoexceptCheck.cpp
   UndelegatedConstructor.cpp
   UniqueptrResetReleaseCheck.cpp
   UnusedAliasDeclsCheck.cpp
   UnusedParametersCheck.cpp
   UnusedRAIICheck.cpp
   UnusedUsingDeclsCheck.cpp
   UseAfterMoveCheck.cpp
   VirtualNearMissCheck.cpp

clang-tidy/misc/MiscTidyModule.cpp

 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
 #include "SuspiciousSemicolonCheck.h"
 #include "SuspiciousStringCompareCheck.h"
 #include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
 #include "UnconventionalAssignOperatorCheck.h"
+#include "ThrowWithNoexceptCheck.h"
 #include "UndelegatedConstructor.h"
 #include "UniqueptrResetReleaseCheck.h"
 #include "UnusedAliasDeclsCheck.h"
 #include "UnusedParametersCheck.h"
 #include "UnusedRAIICheck.h"
 #include "UnusedUsingDeclsCheck.h"
 #include "UseAfterMoveCheck.h"
 #include "VirtualNearMissCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
         "misc-suspicious-semicolon");
     CheckFactories.registerCheck<SuspiciousStringCompareCheck>(
         "misc-suspicious-string-compare");
     CheckFactories.registerCheck<SwappedArgumentsCheck>(
         "misc-swapped-arguments");
     CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>(
         "misc-throw-by-value-catch-by-reference");
+    CheckFactories.registerCheck<ThrowWithNoexceptCheck>(
+        "misc-throw-with-noexcept");
     CheckFactories.registerCheck<UndelegatedConstructorCheck>(
         "misc-undelegated-constructor");
     CheckFactories.registerCheck<UniqueptrResetReleaseCheck>(
         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedAliasDeclsCheck>(
         "misc-unused-alias-decls");
     CheckFactories.registerCheck<UnusedParametersCheck>(
         "misc-unused-parameters");

clang-tidy/misc/ThrowWithNoexceptCheck.h

+//===--- ThrowWithNoexceptCheck.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_THROW_WITH_NOEXCEPT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_WITH_NOEXCEPT_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+///\brief Warns about using throw in function declared as noexcept.
+/// It complains about every throw, even if it is caught later.
+class ThrowWithNoexceptCheck : public ClangTidyCheck {
+public:
+  ThrowWithNoexceptCheck(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_THROW_WITH_NOEXCEPT_H

clang-tidy/misc/ThrowWithNoexceptCheck.cpp

+//===--- ThrowWithNoexceptCheck.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 "ThrowWithNoexceptCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+void ThrowWithNoexceptCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus11)
+    return;
+  Finder->addMatcher(
+      cxxThrowExpr(stmt(forFunction(functionDecl(isNoThrow()).bind("func"))))
+          .bind("throw"),
+      this);
+}
+
+void ThrowWithNoexceptCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("func");
+  const auto *Throw = Result.Nodes.getNodeAs<Stmt>("throw");
+
+  diag(Throw->getLocStart(), "'throw' expression in a function declared with a "
+                             "non-throwing exception specification");
+
+  llvm::SmallVector<SourceRange, 5> NoExceptRanges;
+  for (const auto *Redecl : Function->redecls()) {
+    SourceRange NoExceptRange =
+        Redecl->getExceptionSpecSourceRange();
+
+    if (NoExceptRange.isValid()) {
+      NoExceptRanges.push_back(NoExceptRange);
+    } else {
+      // If a single one is not valid, we cannot apply the fix as we need to
+      // remove noexcept in all declarations for the fix to be effective.
+      NoExceptRanges.clear();
+      break;
+    }
+  }
+
+  for (const auto &NoExceptRange : NoExceptRanges) {
+    // FIXME use DiagnosticIDs::Level::Note
+    diag(NoExceptRange.getBegin(), "in a function declared no-throw here:", DiagnosticIDs::Note)
+        << FixItHint::CreateRemoval(NoExceptRange);
+  }
+}
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
-The improvements are...
+- New `misc-throw-with-noexcept
+  <http://clang.llvm.org/extra/clang-tidy/checks/misc-throw-with-noexcept.html>`_ check
+
+  Flags ``throw`` statements in functions marked as no-throw.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/list.rst

.. toctree::
    misc-string-integer-assignment
    misc-string-literal-with-embedded-nul
    misc-suspicious-enum-usage
    misc-suspicious-missing-comma
    misc-suspicious-semicolon
    misc-suspicious-string-compare
    misc-swapped-arguments
    misc-throw-by-value-catch-by-reference
+   misc-throw-with-noexcept
    misc-unconventional-assign-operator
    misc-undelegated-constructor
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-raii
    misc-unused-using-decls
    misc-use-after-move

docs/clang-tidy/checks/misc-throw-with-noexcept.rst

+.. title:: clang-tidy - misc-throw-with-noexcept
+
+misc-throw-with-noexcept
+========================
+
+This check finds cases of using ``throw`` in a function declared
+with a non-throwing exception specification.
+
+Please note that the warning is issued even if the exception is caught within
+the same function, as that would be probably a bad style anyway.
+
+It removes the exception specification as a fix.
+
+
+  .. code-block:: c++
+
+    void f() noexcept {
+      throw 42;
+    }
+
+    // Will be changed to
+    void f() {
+      throw 42;
+    }

test/clang-tidy/misc-throw-with-noexcept.cpp

+// RUN: %check_clang_tidy %s misc-throw-with-noexcept %t
+
+void f_throw_with_ne() noexcept(true) {
+  {
+    throw 5;
+  }
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-6]]:24: note: in a function declared no-throw here:
+// CHECK-FIXES: void f_throw_with_ne() {
+
+void f_noexcept_false() noexcept(false) {
+  throw 5;
+}
+
+void f_decl_only() noexcept;
+
+// Controversial example
+void throw_and_catch() noexcept(true) {
+  try {
+    throw 5;
+  } catch (...) {
+  }
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:5: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-7]]:24: note: in a function declared no-throw here:
+// CHECK-FIXES: void throw_and_catch() {
+
+void with_parens() noexcept((true)) {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:2: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:20: note: in a function declared no-throw here:
+// CHECK-FIXES: void with_parens() {
+
+
+void with_parens_and_spaces() noexcept    (  (true)  ) {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:2: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:31: note: in a function declared no-throw here:
+// CHECK-FIXES: void with_parens_and_spaces() {
+
+class Class {
+  void InClass() const noexcept(true) {
+    throw 42;
+  }
+};
+// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-5]]:24: note: in a function declared no-throw here:
+// CHECK-FIXES: void InClass() const {
+
+
+void forward_declared() noexcept;
+
+void forward_declared() noexcept {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:2: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:25: note: in a function declared no-throw here:
+// CHECK-MESSAGES: :[[@LINE-7]]:25: note: in a function declared no-throw here:
+// CHECK-FIXES: void forward_declared() ;
+// CHECK-FIXES: void forward_declared() {
+
+void getFunction() noexcept {
+  struct X {
+    static void inner()
+    {
+        throw 42;
+    }
+  };
+}
+
+void dynamic_exception_spec() throw() {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:31: note: in a function declared no-throw here:
+// CHECK-FIXES: void dynamic_exception_spec() {
+
+#define NOEXCEPT noexcept
+
+void with_macro() NOEXCEPT {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:19: note: in a function declared no-throw here:
+// CHECK-FIXES: void with_macro() {
+
+template<typename T> int template_function() noexcept {
+  throw 42;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:46: note: in a function declared no-throw here:
+// CHECK-FIXES: template<typename T> int template_function() {
+
+template<typename T> class template_class {
+  int throw_in_member() noexcept {
+    throw 42;
+  }
+  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: 'throw' expression in a function declared with a non-throwing exception specification [misc-throw-with-noexcept]
+  // CHECK-MESSAGES: :[[@LINE-4]]:25: note: in a function declared no-throw here:
+  // CHECK-FIXES: int throw_in_member() {
+};
+
+void instantiations() {
+  template_function<int>();
+  template_function<float>();
+  template_class<int> c1;
+  template_class<float> c2;
+}