[clang-tidy] New checker to replace dynamic exception specifications

[hintonda]

Summary

New checker to replace dynamic exception
specifications

This is an alternative to D18575 which relied on reparsing the decl to
find the location of dynamic exception specifications, but couldn't
deal with preprocessor conditionals correctly without reparsing the
entire file.

This approach uses D20428 to find dynamic exception specification
locations and handles all cases correctly.

[alexfh]

Removing from my dashboard until D20428 is submitted.

[hintonda]

Update matcher to use functionProtoType instead of functionType.

[alexfh]

Removing from my dashboard until D20428 is submitted.

[hintonda]

Updated patch.

[malcolm.parsons]

clang-tidy/modernize/UseNoexceptCheck.h

19 ↗

(On Diff #83371)

Unused?

docs/clang-tidy/checks/modernize-use-noexcept.rst

38 ↗

(On Diff #83371)

typo: equivelent -> equivalent.

[hintonda]

clang-tidy/modernize/UseNoexceptCheck.h

19 ↗

(On Diff #83371)

Good catch -- left over from a previous version.

docs/clang-tidy/checks/modernize-use-noexcept.rst

38 ↗

(On Diff #83371)

Thanks! Spelling isn't my strong suit.

[hintonda]

• Addressed comments.

[mgehre]

Hi,
this is a good idea for a check.

I would prefer when the FixIt just removes throw(A,B) specifier, instead of replacing it by noexcept(false),
because noexcept(false) means the same things as having no noexcept specifier at all.
And less code to read means its easier to understand.

[hintonda]

I could be wrong (please let me know if I am), but my understanding is:

// Does not throw
throw() --> noexcept == noexcept(true)

// Does throw
throw(something) --> noexcept(false)

Please see http://en.cppreference.com/w/cpp/language/noexcept_spec

[aaron.ballman]

In D20693#638062, @mgehre wrote:

Hi,
this is a good idea for a check.

I would prefer when the FixIt just removes throw(A,B) specifier, instead of replacing it by noexcept(false),
because noexcept(false) means the same things as having no noexcept specifier at all.
And less code to read means its easier to understand.

If the API designer explicitly specified "this function can throw A or B", I think a more helpful FixIt is to specify noexcept(false) explicitly rather than leave off any information about the exception specification. The explicit nature of the dynamic exception specification suggests the API designer intended for the user to know more information about whether the function throws or not, so it's a bit hostile to replace that with no information about whether the function throws or not (even if it's functionally equivalent).

[mgehre]

I'm working on code bases where their is no manually written noexcept(false) anywhere,
and I don't think the FixIt should look different than manually written code.
At least a configuration option for the check would be nice.

[hintonda]

Matthias, I think you make a good point. While noexcept(expr) is valuable, noexcept(false) adds no value. Therefore, I think we should do as you suggest, i.e.:

s/throw()/noexcept/
s/throw(something)//

Aaron, does this work for you?

[aaron.ballman]

In D20693#639030, @hintonda wrote:

Matthias, I think you make a good point. While noexcept(expr) is valuable, noexcept(false) adds no value. Therefore, I think we should do as you suggest, i.e.:

s/throw()/noexcept/
s/throw(something)//

Aaron, does this work for you?

I think it makes a reasonable option, but I think it should be off by default. Again, I think that's hostile towards users to remove an explicit exception specification entirely when there was an explicit dynamic exception specification written on the function signature. noexcept(false) is a stronger signal to anyone reading the signature than no exception specification whatsoever.

Be careful, though, not to break code by removing the exception specification. These two are *not* equivalent, for instance:

struct S {
  ~S() noexcept(false);
  void operator delete(void *ptr) noexcept(false); 
};

struct T {
  ~T(); // Is actually noexcept(true) by default!
  void operator delete(void *ptr); // Is actually noexcept(true) by default!
};

[hintonda]

• Omit noexcept(false) replacement except for dtor and operator delete.

[alexfh]

clang-tidy/modernize/UseNoexceptCheck.cpp

100 ↗

(On Diff #83588)

Did you consider auto-detection approach like in getFallthroughAttrSpelling in tools/clang/lib/Sema/AnalysisBasedWarnings.cpp?

105 ↗

(On Diff #83588)

I suspect this won't work when the range is not contiguous, e.g. starts in a macro definition and ends outside of it:

#define T throw
void f() T(a, b) {}

Can you try this test (or construct something similar that will actually break this code)? In case it doesn't work, Lexer::makeFileCharRange is the standard way to get a contiguous file range corresponding to a source range (if possible).

docs/clang-tidy/checks/modernize-use-noexcept.rst

6–8 ↗

(On Diff #83588)

This description doesn't say why noexcept is better.

[malcolm.parsons]

clang-tidy/modernize/UseNoexceptCheck.cpp

100 ↗

(On Diff #83588)

cpp11-migrate used to do this for -add-override - rL183001.
clang-tidy's modernize-use-override check doesn't even have an option.

[aaron.ballman]

clang-tidy/modernize/UseNoexceptCheck.cpp

41 ↗

(On Diff #83588)

Shouldn't we require C++11 or later?

64 ↗

(On Diff #83588)

Will this catch pointers to member functions as well?

struct S {
  void f() throw();    
};

void f(void (S::*)() throw()) {
    
}

68 ↗

(On Diff #83588)

Also missing: typedefs and using declarations.

docs/clang-tidy/checks/modernize-use-noexcept.rst

30 ↗

(On Diff #83588)

I continue to object to removing the explicit exception specification entirely as the default behavior without strong justification. Further. there is no option to control this behavior.

38 ↗

(On Diff #83588)

I'm not certain I understand the justification of calling out older compilers or suggesting use of throw(). The check will continually flag throw() and try to recommend noexcept in its place, won't it? At least, that's how I read the preceding paragraph.

I think the macro replacement is a reasonable feature, but I think the check only makes sense for C++11 or later, since C++98 users really have no alternatives to dynamic exception specifications.

[hintonda]

clang-tidy/modernize/UseNoexceptCheck.cpp

64 ↗

(On Diff #83588)

Added your test, but will need to change matcher to catch it.

68 ↗

(On Diff #83588)

As far as I know, it isn't legal to add dynamic exception specifications to typedefs and using declarations.

100 ↗

(On Diff #83588)

NoexceptMacro is a user option. I'm just tested whether or not the user provided anything. Perhaps I should pick a better name. Would NoexceptMacroOption be better?

Did I misunderstand your comment?

105 ↗

(On Diff #83588)

As you suspected, I wasn't handling this case correctly. I've made the change you suggested and will check in shortly.

docs/clang-tidy/checks/modernize-use-noexcept.rst

30 ↗

(On Diff #83588)

I tried to make sure it's only applied where appropriate. If I missed a case, please let me know, but I'm not sure an option "just in case" is right solution.

However, I did try to structure the code in a way to make it easy to add an option if that turns out the be the right thing to do.

38 ↗

(On Diff #83588)

Libraries, e.g., libc++, that need to support both multiple versions of the standard, use macros to switch between throw() and noexcept.

So this option was designed to be libc++ friendly. If that's not appropriate, I can remove it.

[hintonda]

• Addressed comments.

[aaron.ballman]

clang-tidy/modernize/UseNoexceptCheck.cpp

68 ↗

(On Diff #83588)

Hmm, I thought you could, at least in C++17, since it's now part of the function's type. However, I don't have a standard in front of me at the moment, so I'll have to double-check. It can always be added in a follow-up patch and need not block this one.

However, I do know the following is allowed in a typedef, and I don't think your existing ParmVarDecl matcher will catch it:

typedef void (*fp)(void (*f)(int) throw());

docs/clang-tidy/checks/modernize-use-noexcept.rst

30 ↗

(On Diff #83588)

The behavior as it's implemented now is not the behavior I would expect from such a check -- I think that throw(int) should get a FixIt to noexcept(false) rather than no noexcept clause whatsoever. Despite them being functionally equivalent in most cases, the explicit nature of the dynamic exception specification should be retained with an explicit noexcept exception specification, not discarded. If you really want throw(int) to be modified to have no explicit exception specification, I think that should be an option (off by default). If you would rather not make an option, then I think the explicit exception specification should remain.

38 ↗

(On Diff #83588)

I think the *option* is fine; I think the wording is confusing. How about:

Alternatively, users can also use :option:`ReplacementString` to
specify a macro to use instead of ``noexcept``.  This is useful when
maintaining source code that uses custom exception specification marking
other than ``noexcept``.

[hintonda]

clang-tidy/modernize/UseNoexceptCheck.cpp

68 ↗

(On Diff #83588)

clang doesn't allow dynamic exception specs in typedef or using declarations for either c++11 or c++14, but does in c++1z since throw() is an alias for noexcept. I'll try to add an appropriate test to highlight this.

I've added your typedef example -- thanks for suggesting it -- and the matcher does catch it and does the appropriate fixit.

docs/clang-tidy/checks/modernize-use-noexcept.rst

30 ↗

(On Diff #83588)

Makes sense. Will do.

38 ↗

(On Diff #83588)

Ah, okay, that sounds much better. I'll make this change shortly.

[alexfh]

clang-tidy/modernize/UseNoexceptCheck.cpp

99 ↗

(On Diff #83827)

I suspect there might be valid code that will trigger this assertion. I would issue the diagnostic, just without a FixItHint.

111 ↗

(On Diff #83827)

The message neither explains what's wrong with the code, nor says what is a better alternative. Something like "dynamic exception specification '%0' is so 1998 <actually explain what's wrong with it>; consider using 'noexcept(...)' <real suggestion>" would lead to less user confusion.

docs/clang-tidy/checks/modernize-use-noexcept.rst

6–8 ↗

(On Diff #83588)

This still needs to be addressed.

[hintonda]

docs/clang-tidy/checks/modernize-use-noexcept.rst

6–8 ↗

(On Diff #83588)

Absolutely, but I'll probably do all the code changes first while it's still fresh in my mind.

[aaron.ballman]

docs/clang-tidy/checks/modernize-use-noexcept.rst

6–8 ↗

(On Diff #83588)

Since we're talking about documentation, should we note that this check does produce a subtle, obscure change in behavior? When you have throw() on a function signature and that function winds up throwing something, this would result in std::unexpected() being called. When that gets modified to be noexcept, the call to std::unexpected() is replaced by a call to std::terminate(). This hopefully does not break any code, but we may want to document the fact that failing to honor a dynamic exception specification is slightly different than failing to honor an exception specification so that users are aware of the slightly different semantics.

[hintonda]

• Add support for matching MemberPointerType's.
• Add noexcept(false) option plus test; allow invalid replacement ranges; enhance diagnostics.
• Updated docs.

[hintonda]

Thanks for all the feedback. I've tried to address all your comments, and reworked the documentation. Please let me know if I missed or misunderstood anything.

[hintonda]

• Fix diagnostic when removing throwing specs.

[hintonda]

• Rebased.

[alexfh]

clang-tidy/modernize/UseNoexceptCheck.cpp

20–33 ↗

(On Diff #85291)

Lexer::getSourceText should do the same thing, I guess.

99 ↗

(On Diff #85291)

Does it actually need template to compile?

103 ↗

(On Diff #85291)

CharSourceRange::getTokenRange(Range) is easier to understand.

test/clang-tidy/modernize-use-noexcept.cpp

87 ↗

(On Diff #85291)

Please add a test with templates and multiple instantiations, e.g.:

template<typename T>
void qqq() noexcept {}
void www() { qqq<int>(); qqq<double>(); }

Same for member functions.

[hintonda]

• Addressed comments and added additional test cases.

[alexfh]

LGTM, if Aaron has no concerns.

Thank you for the new check!

[aaron.ballman]

Yes, this LGTM as well. Thank you for working on this!

[hintonda]

Great, thanks. Could you commit for me?

[aaron.ballman]

In D20693#658087, @hintonda wrote:

Great, thanks. Could you commit for me?

Certainly! I've commit in r293217.

[aaron.ballman]

There were some issues with failing tests that caused this commit to need to be reverted in r293267

See for instance: http://lab.llvm.org:8011/builders/clang-cmake-aarch64-full/builds/1039

Eugene Zelenko also had some small fixes you might want to incorporate as well before recommitting (see r293234).

[hintonda]

Thanks and sorry for the breakage. Unfortunately, I'm unable to reproduce locally (OSX), but will try to get access to linux box this weekend.

Seems to be related to memory corruption wrt to improper StringRef usage, but I can't say for sure yet.

[hintonda]

Reopening due to test failures on Linux -- was rolled back.

[hintonda]

In order to fix diagnostic corruption in some of the buildbot tests
(unable to reproduce locally):

• make NoexceptMacro a static variable so it's lifetime doesn't end when UseNoexceptCheck is destroyed.

• pass a const char* instead of a StringRef to DiagnosticBuilder so it won't create a temporary std::string and cache the address of the temporary char * it owns.

[alexfh]

In D20693#774693, @hintonda wrote:

In order to fix diagnostic corruption in some of the buildbot tests
(unable to reproduce locally):

• make NoexceptMacro a static variable so it's lifetime doesn't end when UseNoexceptCheck is destroyed.

• pass a const char* instead of a StringRef to DiagnosticBuilder so it won't create a temporary std::string and cache the address of the temporary char * it owns.

That's pretty hacky, even if this fixes the immediate issue (which I'm somewhat skeptical about). Do you have failure logs saved somewhere, by chance? If not, I'd suggest to resubmit the original patch (without these two hacks) and grab the fresh failure logs. Another suggestion is to run the tests with asan (and maybe with msan) to see, whether the issue can be detected by the sanitizers.

[alexfh]

In any case, I'm strongly against these hacks, please revert them.

[hintonda]

• Rollback to previous version: rebased + r293218 and r293234.

[hintonda]

Unfortunately, the logs are no longer available, and I don't have copies.

However, I think I know what's going on, so I'll try to submit a fix later today.

[hintonda]

• Only pass %2 parameter if %2 is included in format.

[alexfh]

In D20693#775014, @hintonda wrote:

• Only pass %2 parameter if %2 is included in format.

I thought, DiagnosticsBuilder handles placeholders in conditional parts correctly. Did you find an evidence of the opposite? Can you add a test that consistently fails?

clang-tidy/modernize/UseNoexceptCheck.h

42 ↗

(On Diff #101708)

This can also be const for consistency with how options are handled in this and other checks.

[alexfh]

In D20693#775153, @alexfh wrote:

In D20693#775014, @hintonda wrote:

• Only pass %2 parameter if %2 is included in format.

I thought, DiagnosticsBuilder handles placeholders in conditional parts correctly. Did you find an evidence of the opposite? Can you add a test that consistently fails?

(without your latest change that is)

[hintonda]

I have not, as yet, been able to reproduce the buildbot failures. They were essentially intermittent seg-faults, and corrupt diag output.

I will work on creating a test that can reproduce the problem.

[alexfh]

In D20693#775197, @hintonda wrote:

I have not, as yet, been able to reproduce the buildbot failures. They were essentially intermittent seg-faults, and corrupt diag output.

I will work on creating a test that can reproduce the problem.

As I said, we could re-submit the patch (without speculative fixes) and see whether the buildbots break again. One more suggestion is to run the tests with asan. Have you tried this?

[hintonda]

• Rollback last change.

[hintonda]

Just ran asan on linux and we have a heap-use-after-free in the std::string ctor.

Here's a partial stack dump:

4980==ERROR: AddressSanitizer: heap-use-after-free on address 0x604000024328 at pc 0x00000057ad32 bp 0x7ffd240a7f50 sp 0x7ffd240a7700

READ of size 8 at 0x604000024328 thread T0

#0 0x57ad31 in __interceptor_memcpy.part.36 /home/d80049854/projects/clang/4.0.0/llvm/projects/compiler-rt/lib/asan/../sanitizer_common/sanitizer_common_interceptors.inc:655
#1 0x6c5960 in char* std::string::_S_construct<char const*>(char const*, char const*, std::allocator<char> const&, std::forward_iterator_tag) /usr/lib/gcc/x86_64-linux-gnu/6.2.0/../../../../include/c++/6.2.0/bits/basic_string.tcc:580:6
#2 0x7fe7bd7bc98a in std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, unsigned long, std::allocator<char> const&) (/usr/lib/x86_64-linux-gnu/libstdc++.so.6+0xc598a)
#3 0x67b89f in llvm::StringRef::str() const /home/d80049854/projects/clang/llvm/include/llvm/ADT/StringRef.h:230:14
#4 0x67b3dd in llvm::StringRef::operator std::string() const /home/d80049854/projects/clang/llvm/include/llvm/ADT/StringRef.h:257:14
#5 0xd679d2 in clang::FixItHint::CreateReplacement(clang::CharSourceRange, llvm::StringRef) /home/d80049854/projects/clang/llvm/tools/clang/include/clang/Basic/Diagnostic.h:131:25
#6 0x1213006 in clang::tidy::modernize::UseNoexceptCheck::check(clang::ast_matchers::MatchFinder::MatchResult const&) /home/d80049854/projects/clang/llvm/tools/clang/tools/extra/clang-tidy/modernize/U

$ ../../4.0.0/build/Release/bin/clang -v
clang version 4.0.0 (tags/RELEASE_400/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /home/d80049854/projects/clang/build/Debug/../../4.0.0/build/Release/bin
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.6
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.6.4
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.8
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.8.4
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.9
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/4.9.3
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/5
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/5.4.1
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/6
Found candidate GCC installation: /usr/lib/gcc/x86_64-linux-gnu/6.2.0
Selected GCC installation: /usr/lib/gcc/x86_64-linux-gnu/6.2.0
Candidate multilib: .;@m64
Selected multilib: .;@m64

stdlibc++ from gcc 6.2:

$ g++-6 -v
Using built-in specs.
COLLECT_GCC=g++-6
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/6/lto-wrapper
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 6.2.0-3ubuntu11~14.04' --with-bugurl=file:///usr/share/doc/gcc-6/README.Bugs --enable-languages=c,ada,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-6 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=gcc4-compatible --disable-libstdcxx-dual-abi --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-6-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-6-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-6-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 6.2.0 20160901 (Ubuntu 6.2.0-3ubuntu11~14.04)

$ ldd bin/clang-tidy

linux-vdso.so.1 =>  (0x00007ffde1996000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f6104f2a000)
librt.so.1 => /lib/x86_64-linux-gnu/librt.so.1 (0x00007f6104d22000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f6104b1e000)
libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f61048f5000)
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f61045ef000)
libstdc++.so.6 => /usr/lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f61042dd000)
libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f61040c6000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f6103d01000)
/lib64/ld-linux-x86-64.so.2 (0x00007f6105148000)

[hintonda]

btw, here's how I built it, in case that matters...

CC=../../4.0.0/build/Release/bin/clang CXX=../../4.0.0/build/Release/bin/clang++ \
cmake ../../llvm/ \
-GNinja \
-DLLVM_USE_SANITIZER=Address \
-DCMAKE_BUILD_TYPE=Debug \
-DLLVM_TARGETS_TO_BUILD="X86" \
-DLLVM_PARALLEL_LINK_JOBS=4

[hintonda]

Here's a simple example that demonstrates the corruption I'm seeing:

#include "llvm/ADT/StringRef.h"

int main() {

std::string ss = "";
llvm::StringRef Ref = true ? "noexcept" : ss;
std::string s = Ref;
return 0;

}

[hintonda]

• Make sure types for ternary operator are the same.

[alexfh]

Now that you found the root cause, this looks like a proper fix ;)

Thank you! LG

[hintonda]

Great, thanks for you help.

Could you commit this for me?

[alexfh]

In D20693#776030, @hintonda wrote:

Great, thanks for you help.

Could you commit this for me?

Sure, running tests...

clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt

add_clang_library(clangTidyModernizeModule
   ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
   UseAutoCheck.cpp
   UseBoolLiteralsCheck.cpp
   UseDefaultMemberInitCheck.cpp
   UseEmplaceCheck.cpp
   UseEqualsDefaultCheck.cpp
   UseEqualsDeleteCheck.cpp
+  UseNoexceptCheck.cpp
   UseNullptrCheck.cpp
   UseOverrideCheck.cpp
   UseTransparentFunctorsCheck.cpp
   UseUsingCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyReadabilityModule
   clangTidyUtils
   )

clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp

 #include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
 #include "UseAutoCheck.h"
 #include "UseBoolLiteralsCheck.h"
 #include "UseDefaultMemberInitCheck.h"
 #include "UseEmplaceCheck.h"
 #include "UseEqualsDefaultCheck.h"
 #include "UseEqualsDeleteCheck.h"
+#include "UseNoexceptCheck.h"
 #include "UseNullptrCheck.h"
 #include "UseOverrideCheck.h"
 #include "UseTransparentFunctorsCheck.h"
 #include "UseUsingCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<UseBoolLiteralsCheck>(
         "modernize-use-bool-literals");
     CheckFactories.registerCheck<UseDefaultMemberInitCheck>(
         "modernize-use-default-member-init");
     CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");
     CheckFactories.registerCheck<UseEqualsDefaultCheck>("modernize-use-equals-default");
     CheckFactories.registerCheck<UseEqualsDeleteCheck>(
         "modernize-use-equals-delete");
+    CheckFactories.registerCheck<UseNoexceptCheck>("modernize-use-noexcept");
     CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr");
     CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override");
     CheckFactories.registerCheck<UseTransparentFunctorsCheck>(
         "modernize-use-transparent-functors");
     CheckFactories.registerCheck<UseUsingCheck>("modernize-use-using");
   }
 
   ClangTidyOptions getModuleOptions() override {

clang-tools-extra/trunk/clang-tidy/modernize/UseNoexceptCheck.h

+//===--- UseNoexceptCheck.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_MODERNIZE_USE_NOEXCEPT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// \brief Replace dynamic exception specifications, with
+/// `noexcept` (or user-defined macro) or `noexcept(false)`.
+/// \code
+///   void foo() throw();
+///   void bar() throw(int);
+/// \endcode
+/// Is converted to:
+/// \code
+///   void foo() ;
+//    void bar() noexcept(false);
+/// \endcode
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-noexcept.html
+class UseNoexceptCheck : public ClangTidyCheck {
+public:
+  UseNoexceptCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const std::string NoexceptMacro;
+  bool UseNoexceptFalse;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H

clang-tools-extra/trunk/clang-tidy/modernize/UseNoexceptCheck.cpp

+//===--- UseNoexceptCheck.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 "UseNoexceptCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+UseNoexceptCheck::UseNoexceptCheck(StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      NoexceptMacro(Options.get("ReplacementString", "")),
+      UseNoexceptFalse(Options.get("UseNoexceptFalse", true)) {}
+
+void UseNoexceptCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "ReplacementString", NoexceptMacro);
+  Options.store(Opts, "UseNoexceptFalse", UseNoexceptFalse);
+}
+
+void UseNoexceptCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus11)
+    return;
+
+  Finder->addMatcher(
+      functionDecl(
+          cxxMethodDecl(
+              hasTypeLoc(loc(functionProtoType(hasDynamicExceptionSpec()))),
+              anyOf(hasOverloadedOperatorName("delete[]"),
+                    hasOverloadedOperatorName("delete"), cxxDestructorDecl()))
+              .bind("del-dtor"))
+          .bind("funcDecl"),
+      this);
+
+  Finder->addMatcher(
+      functionDecl(
+          hasTypeLoc(loc(functionProtoType(hasDynamicExceptionSpec()))),
+          unless(anyOf(hasOverloadedOperatorName("delete[]"),
+                       hasOverloadedOperatorName("delete"),
+                       cxxDestructorDecl())))
+          .bind("funcDecl"),
+      this);
+
+  Finder->addMatcher(
+      parmVarDecl(anyOf(hasType(pointerType(pointee(parenType(innerType(
+                            functionProtoType(hasDynamicExceptionSpec())))))),
+                        hasType(memberPointerType(pointee(parenType(innerType(
+                            functionProtoType(hasDynamicExceptionSpec()))))))))
+          .bind("parmVarDecl"),
+      this);
+}
+
+void UseNoexceptCheck::check(const MatchFinder::MatchResult &Result) {
+  const FunctionProtoType *FnTy = nullptr;
+  bool DtorOrOperatorDel = false;
+  SourceRange Range;
+
+  if (const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>("funcDecl")) {
+    DtorOrOperatorDel = Result.Nodes.getNodeAs<FunctionDecl>("del-dtor");
+    FnTy = FuncDecl->getType()->getAs<FunctionProtoType>();
+    if (const auto *TSI = FuncDecl->getTypeSourceInfo())
+      Range =
+          TSI->getTypeLoc().castAs<FunctionTypeLoc>().getExceptionSpecRange();
+  } else if (const auto *ParmDecl =
+                 Result.Nodes.getNodeAs<ParmVarDecl>("parmVarDecl")) {
+    FnTy = ParmDecl->getType()
+               ->getAs<Type>()
+               ->getPointeeType()
+               ->getAs<FunctionProtoType>();
+
+    if (const auto *TSI = ParmDecl->getTypeSourceInfo())
+      Range = TSI->getTypeLoc()
+                  .getNextTypeLoc()
+                  .IgnoreParens()
+                  .castAs<FunctionProtoTypeLoc>()
+                  .getExceptionSpecRange();
+  }
+  CharSourceRange CRange = Lexer::makeFileCharRange(
+      CharSourceRange::getTokenRange(Range), *Result.SourceManager,
+      Result.Context->getLangOpts());
+
+  assert(FnTy && "FunctionProtoType is null.");
+  bool IsNoThrow = FnTy->isNothrow(*Result.Context);
+  StringRef ReplacementStr =
+      IsNoThrow
+          ? NoexceptMacro.empty() ? "noexcept" : NoexceptMacro.c_str()
+          : NoexceptMacro.empty()
+                ? (DtorOrOperatorDel || UseNoexceptFalse) ? "noexcept(false)"
+                                                          : ""
+                : "";
+
+  FixItHint FixIt;
+  if ((IsNoThrow || NoexceptMacro.empty()) && CRange.isValid())
+    FixIt = FixItHint::CreateReplacement(CRange, ReplacementStr);
+
+  diag(Range.getBegin(), "dynamic exception specification '%0' is deprecated; "
+                         "consider %select{using '%2'|removing it}1 instead")
+      << Lexer::getSourceText(CRange, *Result.SourceManager,
+                              Result.Context->getLangOpts())
+      << ReplacementStr.empty() << ReplacementStr << FixIt;
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/docs/ReleaseNotes.rst

 - Improved `modernize-use-emplace
   <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-emplace.html>`_ check
 
   Removes unnecessary ``std::make_pair`` and ``std::make_tuple`` calls in
   push_back calls and turns them into emplace_back. The check now also is able
   to remove user-defined make functions from ``push_back`` calls on containers
   of custom tuple-like types by providing `TupleTypes` and `TupleMakeFunctions`.
 
+ - New `modernize-use-noexcept
+   <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-noexcept.html>`_ check
+
+   Replaces dynamic exception specifications with ``noexcept`` or a user defined macro.
+
 - New `performance-inefficient-vector-operation
   <http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-vector-operation.html>`_ check
 
   Finds possible inefficient vector operations in for loops that may cause
   unnecessary memory reallocations.
 
 - Added `ParameterThreshold` to `readability-function-size
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-function-size.html>`_ check

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. toctree::
    modernize-return-braced-init-list
    modernize-shrink-to-fit
    modernize-use-auto
    modernize-use-bool-literals
    modernize-use-default-member-init
    modernize-use-emplace
    modernize-use-equals-default
    modernize-use-equals-delete
+   modernize-use-noexcept
    modernize-use-nullptr
    modernize-use-override
    modernize-use-transparent-functors
    modernize-use-using
    mpi-buffer-deref
    mpi-type-mismatch
    performance-faster-string-find
    performance-for-range-copy

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-use-noexcept.rst

+.. title:: clang-tidy - modernize-use-noexcept
+
+modernize-use-noexcept
+======================
+
+This check replaces deprecated dynamic exception specifications with
+the appropriate noexcept specification (introduced in C++11).  By
+default this check will replace ``throw()`` with ``noexcept``,
+and ``throw(<exception>[,...])`` or ``throw(...)`` with
+``noexcept(false)``.
+
+Example
+-------
+
+.. code-block:: c++
+
+  void foo() throw();
+  void bar() throw(int) {}
+
+transforms to:
+
+.. code-block:: c++
+
+  void foo() noexcept;
+  void bar() noexcept(false) {}
+
+Options
+-------
+
+.. option:: ReplacementString
+
+Users can use :option:`ReplacementString` to specify a macro to use
+instead of ``noexcept``.  This is useful when maintaining source code
+that uses custom exception specification marking other than
+``noexcept``.  Fix-it hints will only be generated for non-throwing
+specifications.
+
+Example
+^^^^^^^
+
+.. code-block:: c++
+
+  void bar() throw(int);
+  void foo() throw();
+
+transforms to:
+
+.. code-block:: c++
+
+  void bar() throw(int);  // No fix-it generated.
+  void foo() NOEXCEPT;
+
+if the :option:`ReplacementString` option is set to `NOEXCEPT`.
+
+.. option:: UseNoexceptFalse
+
+Enabled by default, disabling will generate fix-it hints that remove
+throwing dynamic exception specs, e.g., ``throw(<something>)``,
+completely without providing a replacement text, except for
+destructors and delete operators that are ``noexcept(true)`` by
+default.
+
+Example
+^^^^^^^
+
+.. code-block:: c++
+
+  void foo() throw(int) {}
+
+  struct bar {
+    void foobar() throw(int);
+    void operator delete(void *ptr) throw(int);
+    void operator delete[](void *ptr) throw(int);
+    ~bar() throw(int);
+  }
+
+transforms to:
+
+.. code-block:: c++
+
+  void foo() {}
+
+  struct bar {
+    void foobar();
+    void operator delete(void *ptr) noexcept(false);
+    void operator delete[](void *ptr) noexcept(false);
+    ~bar() noexcept(false);
+  }
+
+if the :option:`UseNoexceptFalse` option is set to `0`.

clang-tools-extra/trunk/test/clang-tidy/modernize-use-noexcept-macro.cpp

+// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN:   -config="{CheckOptions: [{key: modernize-use-noexcept.ReplacementString, value: 'NOEXCEPT'}]}" \
+// RUN:   -- -std=c++11
+
+// Example definition of NOEXCEPT -- simplified test to see if noexcept is supported.
+#if (__has_feature(cxx_noexcept))
+#define NOEXCEPT noexcept
+#else
+#define NOEXCEPT throw()
+#endif
+
+void bar() throw() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'NOEXCEPT' instead [modernize-use-noexcept]
+// CHECK-FIXES: void bar() NOEXCEPT {}
+
+// Should not trigger a FixItHint, since macros only support noexcept, and this
+// case throws.
+class A {};
+class B {};
+void foobar() throw(A, B);
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: dynamic exception specification 'throw(A, B)' is deprecated; consider removing it instead [modernize-use-noexcept]
+
+// Should not trigger a replacement.
+void foo() noexcept(true);
+
+struct Z {
+  void operator delete(void *ptr) throw();
+  void operator delete[](void *ptr) throw(int);
+  ~Z() throw(int) {}
+};
+// CHECK-MESSAGES: :[[@LINE-4]]:35: warning: dynamic exception specification 'throw()' is deprecated; consider using 'NOEXCEPT' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:37: warning: dynamic exception specification 'throw(int)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:8: warning: dynamic exception specification 'throw(int)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void operator delete(void *ptr) NOEXCEPT;
+// CHECK-FIXES: void operator delete[](void *ptr) throw(int);
+// CHECK-FIXES: ~Z() throw(int) {}

clang-tools-extra/trunk/test/clang-tidy/modernize-use-noexcept-opt.cpp

+// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN:   -config="{CheckOptions: [{key: modernize-use-noexcept.UseNoexceptFalse, value: 0}]}" \
+// RUN:   -- -std=c++11
+
+class A {};
+class B {};
+
+void foo() throw();
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void foo() noexcept;
+
+void bar() throw(...);
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw(...)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void bar() ;
+
+void k() throw(int(int));
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: dynamic exception specification 'throw(int(int))' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void k() ;
+
+void foobar() throw(A, B)
+{}
+// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: dynamic exception specification 'throw(A, B)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void foobar()
+
+void baz(int = (throw A(), 0)) throw(A, B) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: dynamic exception specification 'throw(A, B)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void baz(int = (throw A(), 0)) {}
+
+void g(void (*fp)(void) throw());
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void g(void (*fp)(void) noexcept);
+
+void f(void (*fp)(void) throw(int)) throw(char);
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'throw(int)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:37: warning: dynamic exception specification 'throw(char)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void f(void (*fp)(void) ) ;
+
+#define THROW throw
+void h(void (*fp)(void) THROW(int)) THROW(char);
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'THROW(int)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:37: warning: dynamic exception specification 'THROW(char)' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void h(void (*fp)(void) ) ;
+
+void j() throw(int(int) throw(void(void) throw(int)));
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: dynamic exception specification 'throw(int(int) throw(void(void) throw(int)))' is deprecated; consider removing it instead [modernize-use-noexcept]
+// CHECK-FIXES: void j() ;
+
+class Y {
+  Y() throw() = default;
+};
+// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: Y() noexcept = default;
+
+struct Z {
+  void operator delete(void *ptr) throw();
+  void operator delete[](void *ptr) throw(int);
+  ~Z() throw(int) {}
+};
+// CHECK-MESSAGES: :[[@LINE-4]]:35: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:37: warning: dynamic exception specification 'throw(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:8: warning: dynamic exception specification 'throw(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void operator delete(void *ptr) noexcept;
+// CHECK-FIXES: void operator delete[](void *ptr) noexcept(false);
+// CHECK-FIXES: ~Z() noexcept(false) {}
+
+struct S {
+  void f() throw();
+};
+void f(void (S::*)() throw());
+// CHECK-MESSAGES: :[[@LINE-3]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:22: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void f() noexcept;
+// CHECK-FIXES: void f(void (S::*)() noexcept);
+
+typedef void (*fp)(void (*fp2)(int) throw());
+// CHECK-MESSAGES: :[[@LINE-1]]:37: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: typedef void (*fp)(void (*fp2)(int) noexcept);
+
+// Should not trigger a replacement.
+void titi() noexcept {}
+void toto() noexcept(true) {}
+
+// Should not trigger a replacement.
+void bad()
+#if !__has_feature(cxx_noexcept)
+    throw()
+#endif
+  ;

clang-tools-extra/trunk/test/clang-tidy/modernize-use-noexcept.cpp

+// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN:   -- -std=c++11
+
+class A {};
+class B {};
+
+void foo() throw();
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void foo() noexcept;
+
+template <typename T>
+void foo() throw();
+void footest() { foo<int>(); foo<double>(); }
+// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void foo() noexcept;
+
+void bar() throw(...);
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw(...)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void bar() noexcept(false);
+
+void k() throw(int(int));
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: dynamic exception specification 'throw(int(int))' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void k() noexcept(false);
+
+void foobar() throw(A, B)
+{}
+// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: dynamic exception specification 'throw(A, B)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void foobar() noexcept(false)
+
+void baz(int = (throw A(), 0)) throw(A, B) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: dynamic exception specification 'throw(A, B)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void baz(int = (throw A(), 0)) noexcept(false) {}
+
+void g(void (*fp)(void) throw());
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void g(void (*fp)(void) noexcept);
+
+void f(void (*fp)(void) throw(int)) throw(char);
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'throw(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:37: warning: dynamic exception specification 'throw(char)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void f(void (*fp)(void) noexcept(false)) noexcept(false);
+
+#define THROW throw
+void h(void (*fp)(void) THROW(int)) THROW(char);
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: dynamic exception specification 'THROW(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:37: warning: dynamic exception specification 'THROW(char)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void h(void (*fp)(void) noexcept(false)) noexcept(false);
+
+void j() throw(int(int) throw(void(void) throw(int)));
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: dynamic exception specification 'throw(int(int) throw(void(void) throw(int)))' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void j() noexcept(false);
+
+class Y {
+  Y() throw() = default;
+};
+// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: Y() noexcept = default;
+
+struct Z {
+  void operator delete(void *ptr) throw();
+  void operator delete[](void *ptr) throw(int);
+  ~Z() throw(int) {}
+};
+// CHECK-MESSAGES: :[[@LINE-4]]:35: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:37: warning: dynamic exception specification 'throw(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-4]]:8: warning: dynamic exception specification 'throw(int)' is deprecated; consider using 'noexcept(false)' instead [modernize-use-noexcept]
+// CHECK-FIXES: void operator delete(void *ptr) noexcept;
+// CHECK-FIXES: void operator delete[](void *ptr) noexcept(false);
+// CHECK-FIXES: ~Z() noexcept(false) {}
+
+struct S {
+  void f() throw();
+};
+void f(void (S::*)() throw());
+// CHECK-MESSAGES: :[[@LINE-3]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:22: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void f() noexcept;
+// CHECK-FIXES: void f(void (S::*)() noexcept);
+
+template <typename T>
+struct ST {
+  void foo() throw();
+};
+template <typename T>
+void ft(void (ST<T>::*)() throw());
+// CHECK-MESSAGES: :[[@LINE-4]]:14: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-MESSAGES: :[[@LINE-2]]:27: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void foo() noexcept;
+// CHECK-FIXES: void ft(void (ST<T>::*)() noexcept);
+
+typedef void (*fp)(void (*fp2)(int) throw());
+// CHECK-MESSAGES: :[[@LINE-1]]:37: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: typedef void (*fp)(void (*fp2)(int) noexcept);
+
+// Should not trigger a replacement.
+void titi() noexcept {}
+void toto() noexcept(true) {}
+
+// Should not trigger a replacement.
+void bad()
+#if !__has_feature(cxx_noexcept)
+    throw()
+#endif
+  ;