[clang-tidy] Add more checks for functions which should be noexcept

[AMS21]

Summary

Added new checks

• performance-noexcept-destructor
• performance-noexcept-swap

Also added cppcoreguidlines aliases for the 2 new checks as well as performance-noexcept-move-constructor

This fixes llvm#62154

[PiotrZSL]

Few issues, first we should have single check for a single cppcoreguidelines rule.
And due to that I'm not fan of merging these things, because for example If I would enable this check in my project I woudn't like to enforce noexcept default constructor or destructor. Simply there are other checks for destructors .

This is why better would be to rename this check into performance-noexcept-move-special-functions, and add other checks for swap, hash, default constructor.
Where one for default constructor could be cpp-core-guidelines only check, and swap, hash could have some performance code.
For example in libcxx if hash function is noexcept, then hash value is not cached in container, but when is not noexcept then it's cached. But thats only libcxx.
Also things like compare operators for me should be noexcept...

If you want to keep single check, I'm fine with it, but consider adding option to disable some parts of it (mainly default constructors), and consider including (not necessary in this patch, all compare operators).

Give it a thing...

clang-tools-extra/docs/ReleaseNotes.rst

447

Add release notes info about check rename, best as separate entry.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-special-functions.rst

10 ↗

(On Diff #514879)

Add link to implemented cpp core guidelines rules.
Add reference
C.66: Make move operations noexcept
C.83: For value-like types, consider providing a noexcept swap function.
Same goes to operator == (C.86 rule)
And hash C.89 rule

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

198

This list os for checks,
Add alias under .. csv-table:: Aliases..

clang-tools-extra/docs/clang-tidy/checks/performance/noexcept-special-functions.rst

7 ↗

(On Diff #514879)

user defined default constructor does not need to be noexcept.
There is rule C.44: Prefer default constructors to be simple and non-throwing but that.s just a guideline.

8 ↗

(On Diff #514879)

add entry here why destructors and swap functions should be also noexcept.

[carlosgalvezp]

First of all thank you for the contribution! I had just a quick look so here's some very preliminary comments, will have more time to deeply review during the weekend:

• Unfortunately we cannot simply rename a check like this, since it breaks backwards compatibility. We need a period of 2 major releases where both the new check and the old check (marked as deprecated) co-exist, so people have enough time to port over. Only after those 2 releases can the old check be fully removed.
• Contrary to my comment on Github, I no longer think this should be a cppcoreguideline check, as it does not implement rule F.6. The enforcement required is to flag all functions (not just the special ones) that cannot throw and mark them as noexcept. That's a huge difference with a larger scope and impact in a codebase. I personally think that last bit is impractical in a real-world project, it would add too much noise.
• This check is also used as an alias to another guideline - HiCPP Rule 12.5.4, which strictly only covers move operators. Guideline checks (HiCPP, CppCoreGuidelines) are stricter than the regular checks, and should only cover what they intend to cover - no more, no less.
• Special member functions are also copy constructors & assignments, yet those don't seem to be part of the rule?

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-special-functions.rst

10 ↗

(On Diff #514879)

Since there are different rules for different functions it's probably easier to maintain if we have 1 check per rule. Having a large check doing multiple things and multiple reasons for change can lead to more bugs, churn, renames, etc. What do you think?

[AMS21]

Well first of all thanks for the feedback. I agree not renaming a check which is already used and splitting each special case into it's own check seems like the easier and better way to go.

[AMS21]

Split the changes into 2 new checks and added cppcoreguidelines aliases for all of them.

[AMS21]

Bumping to ask for reviews

[PiotrZSL]

On first glance, looks fine, but I didn't check it too deep.
Leave it open for 1-2 weeks. I will try to check it more deeply.

One thing that I see and do not like is duplication, maybe we could extract some "base check" from those 3 (in next step).

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-move-constructor.rst

5 ↗

(On Diff #518278)

maybe then it should be called cppcoreguidelines-noexcept-move-operations

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

490

this is out of scope of this change, verify this

[AMS21]

Rename cppcoreguidelines-noexcept-move-constructor to cppcoreguidelines-noexcept-move-operations

[AMS21]

Removed unrelated change

[AMS21]

Patch is now open for 2+ weeks. If there are no more reviews, I would kindly ask for someone to push this on my behalf.

[PiotrZSL]

+-LGTM

Only one thing that could be still done here, is to extract some base class from those checks, and move common code there.
I will commit this tomorrow, so if you decide to change anything you can still do that, if not you can always do that in separate patch.

clang-tools-extra/clang-tidy/performance/NoexceptDestructorCheck.cpp

20–24

start with cxxDestructorDecl(unless(isImplicit()), ..., no need for functionDecl.
Also here we may have some issues with template dependent code.

clang-tools-extra/clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

22

I think we could use TK_IgnoreUnlessSpelledInSource instead of all those isImplicit

clang-tools-extra/clang-tidy/performance/NoexceptSwapCheck.cpp

22

i dont think that swap functions can be deleted

[PiotrZSL]

clang-tools-extra/docs/ReleaseNotes.rst

219

you got spelling wrong in these, its clang-tidy, not tify

[AMS21]

Implement the suggested changes

clang-tools-extra/clang-tidy/performance/NoexceptSwapCheck.cpp

22

All functions can be deleted. See cppreference

void swap(int, int) = delete;

Should be valid C++ and not give a no-noexcept warning, so we need to exclude it.

[Dinistro]

I'm getting a linking error by some of the files changed in this revision.

ld.lld: error: undefined symbol: vtable for clang::tidy::performance::NoexceptDestructorCheck
>>> referenced by NoexceptDestructorCheck.h:26 (/home/christianu/repos/llvm-project/clang-tools-extra/clang-tidy/cppcoreguidelines/../performance/NoexceptDestructorCheck.h:26)
>>>               tools/clang/tools/extra/clang-tidy/cppcoreguidelines/CMakeFiles/obj.clangTidyCppCoreGuidelinesModule.dir/CppCoreGuidelinesTidyModule.cpp.o:(std::enable_if<is_invocable_r_v<std::uni
que_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::registerCheck<clang::tidy::performance::NoexceptDestructorCheck>(ll
vm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>, std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::
tidy::ClangTidyCheck>>>::type std::__invoke_r<std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::registerCheck
<clang::tidy::performance::NoexceptDestructorCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>(void clang::tidy::C
langTidyCheckFactories::registerCheck<clang::tidy::performance::NoexceptDestructorCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef&&, clang::tidy:
:ClangTidyContext*&&))
>>> the vtable symbol may be undefined because the class is missing its key function (see https://lld.llvm.org/missingkeyfunction)

ld.lld: error: undefined symbol: vtable for clang::tidy::performance::NoexceptMoveConstructorCheck
>>> referenced by NoexceptMoveConstructorCheck.h:30 (/home/christianu/repos/llvm-project/clang-tools-extra/clang-tidy/cppcoreguidelines/../performance/NoexceptMoveConstructorCheck.h:30)
>>>               tools/clang/tools/extra/clang-tidy/cppcoreguidelines/CMakeFiles/obj.clangTidyCppCoreGuidelinesModule.dir/CppCoreGuidelinesTidyModule.cpp.o:(std::enable_if<is_invocable_r_v<std::uni
que_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::registerCheck<clang::tidy::performance::NoexceptMoveConstructorChec
k>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>, std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<cl
ang::tidy::ClangTidyCheck>>>::type std::__invoke_r<std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::register
Check<clang::tidy::performance::NoexceptMoveConstructorCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>(void clan
g::tidy::ClangTidyCheckFactories::registerCheck<clang::tidy::performance::NoexceptMoveConstructorCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef&
&, clang::tidy::ClangTidyContext*&&))
>>> the vtable symbol may be undefined because the class is missing its key function (see https://lld.llvm.org/missingkeyfunction)

ld.lld: error: undefined symbol: vtable for clang::tidy::performance::NoexceptSwapCheck
>>> referenced by NoexceptSwapCheck.h:26 (/home/christianu/repos/llvm-project/clang-tools-extra/clang-tidy/cppcoreguidelines/../performance/NoexceptSwapCheck.h:26)
>>>               tools/clang/tools/extra/clang-tidy/cppcoreguidelines/CMakeFiles/obj.clangTidyCppCoreGuidelinesModule.dir/CppCoreGuidelinesTidyModule.cpp.o:(std::enable_if<is_invocable_r_v<std::uni
que_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::registerCheck<clang::tidy::performance::NoexceptSwapCheck>(llvm::St
ringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>, std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::
ClangTidyCheck>>>::type std::__invoke_r<std::unique_ptr<clang::tidy::ClangTidyCheck, std::default_delete<clang::tidy::ClangTidyCheck>>, void clang::tidy::ClangTidyCheckFactories::registerCheck<clang
::tidy::performance::NoexceptSwapCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef, clang::tidy::ClangTidyContext*>(void clang::tidy::ClangTidyChec
kFactories::registerCheck<clang::tidy::performance::NoexceptSwapCheck>(llvm::StringRef)::'lambda'(llvm::StringRef, clang::tidy::ClangTidyContext*)&, llvm::StringRef&&, clang::tidy::ClangTidyContext*
&&))
>>> the vtable symbol may be undefined because the class is missing its key function (see https://lld.llvm.org/missingkeyfunction)
clang-16: error: linker command failed with exit code 1 (use -v to see invocation)

I'm building with shared libraries on.

[PiotrZSL]

In D148697#4420359, @Dinistro wrote:

I'm getting a linking error by some of the files changed in this revision.

You shouldn't because this library got dependency on clangTidyPerformanceModule.
Is this a blocker for you, or you can live with this for 1 day ? Until I verify this.

[Dinistro]

In D148697#4421268, @PiotrZSL wrote:

In D148697#4420359, @Dinistro wrote:

I'm getting a linking error by some of the files changed in this revision.

You shouldn't because this library got dependency on clangTidyPerformanceModule.
Is this a blocker for you, or you can live with this for 1 day ? Until I verify this.

I don't necessarily need to build clang-tidy, so it's fine for now.

[PiotrZSL]

In D148697#4421339, @Dinistro wrote:

In D148697#4421268, @PiotrZSL wrote:

In D148697#4420359, @Dinistro wrote:

I'm getting a linking error by some of the files changed in this revision.

You shouldn't because this library got dependency on clangTidyPerformanceModule.
Is this a blocker for you, or you can live with this for 1 day ? Until I verify this.

I don't necessarily need to build clang-tidy, so it's fine for now.

I did a clean build with shared libraries enabled, everything is working.
I do not get those issues. Try a clean-build. I will try to check build with clang-16.

[PiotrZSL]

@Dinistro It compiles & links with clang 16 also (shared libs). So I'm unable to reproduce.

[Dinistro]

In D148697#4421420, @PiotrZSL wrote:

In D148697#4421339, @Dinistro wrote:

In D148697#4421268, @PiotrZSL wrote:

In D148697#4420359, @Dinistro wrote:

I'm getting a linking error by some of the files changed in this revision.

You shouldn't because this library got dependency on clangTidyPerformanceModule.
Is this a blocker for you, or you can live with this for 1 day ? Until I verify this.

I don't necessarily need to build clang-tidy, so it's fine for now.

I did a clean build with shared libraries enabled, everything is working.
I do not get those issues. Try a clean-build. I will try to check build with clang-16.

I tried with a clean build, and I get the exact same issues. Might be caused by the lld and clang-16 combination, not sure.

[Dinistro]

In D148697#4421643, @PiotrZSL wrote:

@Dinistro It compiles & links with clang 16 also (shared libs). So I'm unable to reproduce.

I used the following command to build:

cmake -S/home/christianu/repos/llvm-project/llvm -B/home/christianu/repos/llvm-project/build-clang-tidy -GNinja -DLLVM_ENABLE_LLD=ON -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_ASSERTIONS=ON -DBUILD_SHARED_LIBS=ON -DLLVM_INCLUDE_UTILS=ON -DLLVM_INSTALL_UTILS=ON -DLLVM_BUILD_EXAMPLES=OFF -DLLVM_CCACHE_BUILD=ON -DLLVM_OPTIMIZED_TABLEGEN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_ENABLE_RUNTIMES=openmp

[PiotrZSL]

In D148697#4421739, @Dinistro wrote:

In D148697#4421643, @PiotrZSL wrote:

@Dinistro It compiles & links with clang 16 also (shared libs). So I'm unable to reproduce.

I used the following command to build:

cmake -S/home/christianu/repos/llvm-project/llvm -B/home/christianu/repos/llvm-project/build-clang-tidy -GNinja -DLLVM_ENABLE_LLD=ON -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_ASSERTIONS=ON -DBUILD_SHARED_LIBS=ON -DLLVM_INCLUDE_UTILS=ON -DLLVM_INSTALL_UTILS=ON -DLLVM_BUILD_EXAMPLES=OFF -DLLVM_CCACHE_BUILD=ON -DLLVM_OPTIMIZED_TABLEGEN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_ENABLE_RUNTIMES=openmp

Still no issue on my side. Try cleaning up ccache and directory. Also by looking into code, everything looks fine, dependencies are correctly set.

[nemanjai]

In D148697#4421739, @Dinistro wrote:

In D148697#4421643, @PiotrZSL wrote:

@Dinistro It compiles & links with clang 16 also (shared libs). So I'm unable to reproduce.

I used the following command to build:

cmake -S/home/christianu/repos/llvm-project/llvm -B/home/christianu/repos/llvm-project/build-clang-tidy -GNinja -DLLVM_ENABLE_LLD=ON -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_ASSERTIONS=ON -DBUILD_SHARED_LIBS=ON -DLLVM_INCLUDE_UTILS=ON -DLLVM_INSTALL_UTILS=ON -DLLVM_BUILD_EXAMPLES=OFF -DLLVM_CCACHE_BUILD=ON -DLLVM_OPTIMIZED_TABLEGEN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_ENABLE_RUNTIMES=openmp

It was also causing PPC bots to break. I fixed it in https://reviews.llvm.org/rGffd7a200fdfbd01ef296101647d2f2da91ddfd41

[PiotrZSL]

In D148697#4422629, @nemanjai wrote:

It was also causing PPC bots to break. I fixed it in https://reviews.llvm.org/rGffd7a200fdfbd01ef296101647d2f2da91ddfd41

O, thank you. Thats explain a lot. Because when I look into cmake, clangTidyPerformanceModule were already there because you already added it.

[nemanjai]

In D148697#4422642, @PiotrZSL wrote:

In D148697#4422629, @nemanjai wrote:

It was also causing PPC bots to break. I fixed it in https://reviews.llvm.org/rGffd7a200fdfbd01ef296101647d2f2da91ddfd41

O, thank you. Thats explain a lot. Because when I look into cmake, clangTidyPerformanceModule were already there because you already added it.

Yeah, sorry. I saw that Phabricator automatically added the mention into the Diffusion link but I forgot that it won't add it to the Differential and that I need to add it manually.

[Dinistro]

Sorry for the noise. I didn't pull in between the different runs and was still on the broken version.
Thanks for fixing this issue :)

[shafik]

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

273

To conform with burprone-argument-comment.

Apologies for late review.

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 //===-- CppCoreGuidelinesTidyModule.cpp - clang-tidy ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/NonPrivateMemberVariablesInClassesCheck.h"
 #include "../misc/UnconventionalAssignOperatorCheck.h"
 #include "../modernize/AvoidCArraysCheck.h"
 #include "../modernize/UseDefaultMemberInitCheck.h"
 #include "../modernize/UseOverrideCheck.h"
+#include "../performance/NoexceptDestructorCheck.h"
+#include "../performance/NoexceptMoveConstructorCheck.h"
+#include "../performance/NoexceptSwapCheck.h"
 #include "../readability/MagicNumbersCheck.h"
 #include "AvoidCapturingLambdaCoroutinesCheck.h"
 #include "AvoidConstOrRefDataMembersCheck.h"
 #include "AvoidDoWhileCheck.h"
 #include "AvoidGotoCheck.h"
 #include "AvoidNonConstGlobalVariablesCheck.h"
 #include "AvoidReferenceCoroutineParametersCheck.h"
 #include "InitVariablesCheck.h"
CheckFactories.registerCheck<MacroUsageCheck>(
         "cppcoreguidelines-macro-usage");
     CheckFactories.registerCheck<MisleadingCaptureDefaultByValueCheck>(
         "cppcoreguidelines-misleading-capture-default-by-value");
     CheckFactories.registerCheck<MissingStdForwardCheck>(
         "cppcoreguidelines-missing-std-forward");
     CheckFactories.registerCheck<NarrowingConversionsCheck>(
         "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
+    CheckFactories.registerCheck<performance::NoexceptDestructorCheck>(
+        "cppcoreguidelines-noexcept-destructor");
+    CheckFactories.registerCheck<performance::NoexceptMoveConstructorCheck>(
+        "cppcoreguidelines-noexcept-move-operations");
+    CheckFactories.registerCheck<performance::NoexceptSwapCheck>(
+        "cppcoreguidelines-noexcept-swap");
     CheckFactories.registerCheck<misc::NonPrivateMemberVariablesInClassesCheck>(
         "cppcoreguidelines-non-private-member-variables-in-classes");
     CheckFactories.registerCheck<OwningMemoryCheck>(
         "cppcoreguidelines-owning-memory");
     CheckFactories.registerCheck<PreferMemberInitializerCheck>(
         "cppcoreguidelines-prefer-member-initializer");
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");

clang-tools-extra/clang-tidy/performance/CMakeLists.txt

add_clang_library(clangTidyPerformanceModule
   ImplicitConversionInLoopCheck.cpp
   InefficientAlgorithmCheck.cpp
   InefficientStringConcatenationCheck.cpp
   InefficientVectorOperationCheck.cpp
   MoveConstArgCheck.cpp
   MoveConstructorInitCheck.cpp
   NoAutomaticMoveCheck.cpp
   NoIntToPtrCheck.cpp
+  NoexceptDestructorCheck.cpp
   NoexceptMoveConstructorCheck.cpp
+  NoexceptSwapCheck.cpp
   PerformanceTidyModule.cpp
   TriviallyDestructibleCheck.cpp
   TypePromotionInMathFnCheck.cpp
   UnnecessaryCopyInitialization.cpp
   UnnecessaryValueParamCheck.cpp
 
   LINK_LIBS
   clangTidy

clang-tools-extra/clang-tidy/performance/NoexceptDestructorCheck.h

-//===--- NoexceptMoveConstructorCheck.h - clang-tidy-------------*- C++ -*-===//
+//===--- NoexceptDestructorCheck.h - clang-tidy -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTDESTRUCTORCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTDESTRUCTORCHECK_H
 
 #include "../ClangTidyCheck.h"
 #include "../utils/ExceptionSpecAnalyzer.h"
 
 namespace clang::tidy::performance {
 
-/// The check flags user-defined move constructors and assignment operators not
-/// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
-/// evaluates to `false` (but is not a `false` literal itself).
+/// The check flags destructors not marked with `noexcept` or marked
+/// with `noexcept(expr)` where `expr` evaluates to `false`
+/// (but is not a `false` literal itself).
 ///
-/// Move constructors of all the types used with STL containers, for example,
-/// need to be declared `noexcept`. Otherwise STL will choose copy constructors
-/// instead. The same is valid for move assignment operations.
-class NoexceptMoveConstructorCheck : public ClangTidyCheck {
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/performance/noexcept-destructor.html
+class NoexceptDestructorCheck : public ClangTidyCheck {
 public:
-  NoexceptMoveConstructorCheck(StringRef Name, ClangTidyContext *Context)
+  NoexceptDestructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11 && LangOpts.CXXExceptions;
   }
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   utils::ExceptionSpecAnalyzer SpecAnalyzer;
 };
 
 } // namespace clang::tidy::performance
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTDESTRUCTORCHECK_H

clang-tools-extra/clang-tidy/performance/NoexceptDestructorCheck.cpp

+//===--- NoexceptDestructorCheck.cpp - clang-tidy -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "NoexceptDestructorCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::performance {
+
+void NoexceptDestructorCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      functionDecl(unless(isDeleted()), cxxDestructorDecl()).bind("decl"),
+      this);
+}
+
+void NoexceptDestructorCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>("decl");
+  assert(FuncDecl);
+
+  if (SpecAnalyzer.analyze(FuncDecl) !=
+      utils::ExceptionSpecAnalyzer::State::Throwing)
+    return;
+
+  // Don't complain about nothrow(false), but complain on nothrow(expr)
+  // where expr evaluates to false.
+  const auto *ProtoType = FuncDecl->getType()->castAs<FunctionProtoType>();
+  const Expr *NoexceptExpr = ProtoType->getNoexceptExpr();
+  if (NoexceptExpr) {
+    NoexceptExpr = NoexceptExpr->IgnoreImplicit();
+    if (!isa<CXXBoolLiteralExpr>(NoexceptExpr)) {
+      diag(NoexceptExpr->getExprLoc(),
+           "noexcept specifier on the destructor evaluates to 'false'");
+    }
+    return;
+  }
+
+  auto Diag = diag(FuncDecl->getLocation(), "destructors should "
+                                            "be marked noexcept");
+
+  // Add FixIt hints.
+  const SourceManager &SM = *Result.SourceManager;
+
+  const SourceLocation NoexceptLoc =
+      utils::lexer::getLocationForNoexceptSpecifier(FuncDecl, SM);
+  if (NoexceptLoc.isValid())
+    Diag << FixItHint::CreateInsertion(NoexceptLoc, " noexcept ");
+}
+
+} // namespace clang::tidy::performance

clang-tools-extra/clang-tidy/performance/NoexceptMoveConstructorCheck.h

 
 /// The check flags user-defined move constructors and assignment operators not
 /// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
 /// evaluates to `false` (but is not a `false` literal itself).
 ///
 /// Move constructors of all the types used with STL containers, for example,
 /// need to be declared `noexcept`. Otherwise STL will choose copy constructors
 /// instead. The same is valid for move assignment operations.
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/performance/noexcept-move-constructor.html
 class NoexceptMoveConstructorCheck : public ClangTidyCheck {
 public:
   NoexceptMoveConstructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11 && LangOpts.CXXExceptions;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   utils::ExceptionSpecAnalyzer SpecAnalyzer;
 };
 
 } // namespace clang::tidy::performance
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H

clang-tools-extra/clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

 //===--- NoexceptMoveConstructorCheck.cpp - clang-tidy---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "NoexceptMoveConstructorCheck.h"
+#include "../utils/LexerUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/FixIt.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::performance {
 
 void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      cxxMethodDecl(unless(isImplicit()), unless(isDeleted()),
+      cxxMethodDecl(unless(isDeleted()),
                     anyOf(cxxConstructorDecl(isMoveConstructor()),
                           isMoveAssignmentOperator()))
           .bind("decl"),
       this);
 }
 
 void NoexceptMoveConstructorCheck::check(
     const MatchFinder::MatchResult &Result) {
-  const auto *Decl = Result.Nodes.getNodeAs<CXXMethodDecl>("decl");
-  if (!Decl)
-    return;
+  const auto *FuncDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("decl");
+  assert(FuncDecl);
 
-  if (SpecAnalyzer.analyze(Decl) !=
+  if (SpecAnalyzer.analyze(FuncDecl) !=
       utils::ExceptionSpecAnalyzer::State::Throwing)
     return;
 
-  const bool IsConstructor = CXXConstructorDecl::classof(Decl);
+  const bool IsConstructor = CXXConstructorDecl::classof(FuncDecl);
 
   // Don't complain about nothrow(false), but complain on nothrow(expr)
   // where expr evaluates to false.
-  const auto *ProtoType = Decl->getType()->castAs<FunctionProtoType>();
+  const auto *ProtoType = FuncDecl->getType()->castAs<FunctionProtoType>();
   const Expr *NoexceptExpr = ProtoType->getNoexceptExpr();
   if (NoexceptExpr) {
     NoexceptExpr = NoexceptExpr->IgnoreImplicit();
     if (!isa<CXXBoolLiteralExpr>(NoexceptExpr)) {
       diag(NoexceptExpr->getExprLoc(),
            "noexcept specifier on the move %select{assignment "
            "operator|constructor}0 evaluates to 'false'")
           << IsConstructor;
     }
     return;
   }
 
-  auto Diag = diag(Decl->getLocation(),
+  auto Diag = diag(FuncDecl->getLocation(),
                    "move %select{assignment operator|constructor}0s should "
                    "be marked noexcept")
               << IsConstructor;
   // Add FixIt hints.
+
   const SourceManager &SM = *Result.SourceManager;
-  assert(Decl->getNumParams() > 0);
-  SourceLocation NoexceptLoc =
-      Decl->getParamDecl(Decl->getNumParams() - 1)->getSourceRange().getEnd();
-  if (NoexceptLoc.isValid())
-    NoexceptLoc = Lexer::findLocationAfterToken(
-        NoexceptLoc, tok::r_paren, SM, Result.Context->getLangOpts(), true);
+
+  const SourceLocation NoexceptLoc =
+      utils::lexer::getLocationForNoexceptSpecifier(FuncDecl, SM);
   if (NoexceptLoc.isValid())
     Diag << FixItHint::CreateInsertion(NoexceptLoc, " noexcept ");
-  return;
 }
 
 } // namespace clang::tidy::performance

clang-tools-extra/clang-tidy/performance/NoexceptSwapCheck.h

-//===--- NoexceptMoveConstructorCheck.h - clang-tidy-------------*- C++ -*-===//
+//===--- NoexceptSwapCheck.h - clang-tidy -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTSWAPCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTSWAPCHECK_H
 
 #include "../ClangTidyCheck.h"
 #include "../utils/ExceptionSpecAnalyzer.h"
 
 namespace clang::tidy::performance {
 
-/// The check flags user-defined move constructors and assignment operators not
-/// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
-/// evaluates to `false` (but is not a `false` literal itself).
+/// The check flags swap functions not marked with `noexcept` or marked
+/// with `noexcept(expr)` where `expr` evaluates to `false`
+/// (but is not a `false` literal itself).
 ///
-/// Move constructors of all the types used with STL containers, for example,
-/// need to be declared `noexcept`. Otherwise STL will choose copy constructors
-/// instead. The same is valid for move assignment operations.
-class NoexceptMoveConstructorCheck : public ClangTidyCheck {
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/performance/noexcept-swap.html
+class NoexceptSwapCheck : public ClangTidyCheck {
 public:
-  NoexceptMoveConstructorCheck(StringRef Name, ClangTidyContext *Context)
+  NoexceptSwapCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11 && LangOpts.CXXExceptions;
   }
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   utils::ExceptionSpecAnalyzer SpecAnalyzer;
 };
 
 } // namespace clang::tidy::performance
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTSWAPCHECK_H

clang-tools-extra/clang-tidy/performance/NoexceptSwapCheck.cpp

+//===--- NoexceptSwapCheck.cpp - clang-tidy -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "NoexceptSwapCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::performance {
+
+void NoexceptSwapCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      functionDecl(unless(isDeleted()), hasName("swap")).bind("decl"), this);
+}
+
+void NoexceptSwapCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>("decl");
+  assert(FuncDecl);
+
+  if (SpecAnalyzer.analyze(FuncDecl) !=
+      utils::ExceptionSpecAnalyzer::State::Throwing)
+    return;
+
+  // Don't complain about nothrow(false), but complain on nothrow(expr)
+  // where expr evaluates to false.
+  const auto *ProtoType = FuncDecl->getType()->castAs<FunctionProtoType>();
+  const Expr *NoexceptExpr = ProtoType->getNoexceptExpr();
+  if (NoexceptExpr) {
+    NoexceptExpr = NoexceptExpr->IgnoreImplicit();
+    if (!isa<CXXBoolLiteralExpr>(NoexceptExpr)) {
+      diag(NoexceptExpr->getExprLoc(),
+           "noexcept specifier on swap function evaluates to 'false'");
+    }
+    return;
+  }
+
+  auto Diag = diag(FuncDecl->getLocation(), "swap functions should "
+                                            "be marked noexcept");
+
+  // Add FixIt hints.
+  const SourceManager &SM = *Result.SourceManager;
+
+  const SourceLocation NoexceptLoc =
+      utils::lexer::getLocationForNoexceptSpecifier(FuncDecl, SM);
+  if (NoexceptLoc.isValid())
+    Diag << FixItHint::CreateInsertion(NoexceptLoc, " noexcept ");
+}
+
+} // namespace clang::tidy::performance

clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp

 #include "ImplicitConversionInLoopCheck.h"
 #include "InefficientAlgorithmCheck.h"
 #include "InefficientStringConcatenationCheck.h"
 #include "InefficientVectorOperationCheck.h"
 #include "MoveConstArgCheck.h"
 #include "MoveConstructorInitCheck.h"
 #include "NoAutomaticMoveCheck.h"
 #include "NoIntToPtrCheck.h"
+#include "NoexceptDestructorCheck.h"
 #include "NoexceptMoveConstructorCheck.h"
+#include "NoexceptSwapCheck.h"
 #include "TriviallyDestructibleCheck.h"
 #include "TypePromotionInMathFnCheck.h"
 #include "UnnecessaryCopyInitialization.h"
 #include "UnnecessaryValueParamCheck.h"
 
 namespace clang::tidy {
 namespace performance {
 
CheckFactories.registerCheck<InefficientVectorOperationCheck>(
         "performance-inefficient-vector-operation");
     CheckFactories.registerCheck<MoveConstArgCheck>(
         "performance-move-const-arg");
     CheckFactories.registerCheck<MoveConstructorInitCheck>(
         "performance-move-constructor-init");
     CheckFactories.registerCheck<NoAutomaticMoveCheck>(
         "performance-no-automatic-move");
     CheckFactories.registerCheck<NoIntToPtrCheck>("performance-no-int-to-ptr");
+    CheckFactories.registerCheck<NoexceptDestructorCheck>(
+        "performance-noexcept-destructor");
     CheckFactories.registerCheck<NoexceptMoveConstructorCheck>(
         "performance-noexcept-move-constructor");
+    CheckFactories.registerCheck<NoexceptSwapCheck>(
+        "performance-noexcept-swap");
     CheckFactories.registerCheck<TriviallyDestructibleCheck>(
         "performance-trivially-destructible");
     CheckFactories.registerCheck<TypePromotionInMathFnCheck>(
         "performance-type-promotion-in-math-fn");
     CheckFactories.registerCheck<UnnecessaryCopyInitialization>(
         "performance-unnecessary-copy-initialization");
     CheckFactories.registerCheck<UnnecessaryValueParamCheck>(
         "performance-unnecessary-value-param");

clang-tools-extra/clang-tidy/utils/ExceptionSpecAnalyzer.cpp

 ExceptionSpecAnalyzer::analyzeFunctionEST(const FunctionDecl *FuncDecl,
                                           const FunctionProtoType *FuncProto) {
   if (!FuncDecl || !FuncProto)
     return State::Unknown;
 
   if (isUnresolvedExceptionSpec(FuncProto->getExceptionSpecType()))
     return State::Unknown;
 
+  // A non defaulted destructor without the noexcept specifier is still noexcept
+  if (isa<CXXDestructorDecl>(FuncDecl) &&
+      FuncDecl->getExceptionSpecType() == EST_None)
+    return State::NotThrowing;
+
   switch (FuncProto->canThrow()) {
   case CT_Cannot:
     return State::NotThrowing;
   case CT_Dependent: {
     const Expr *NoexceptExpr = FuncProto->getNoexceptExpr();
     bool Result;
     return (NoexceptExpr && !NoexceptExpr->isValueDependent() &&
             NoexceptExpr->EvaluateAsBooleanCondition(

clang-tools-extra/clang-tidy/utils/LexerUtils.h

std::optional<Token> getQualifyingToken(tok::TokenKind TK,
                                         const ASTContext &Context,
                                         const SourceManager &SM);
 
 /// Stmt->getEndLoc does not always behave the same way depending on Token type.
 /// See implementation for exceptions.
 SourceLocation getUnifiedEndLoc(const Stmt &S, const SourceManager &SM,
                                 const LangOptions &LangOpts);
 
+/// For a given FunctionDecl returns the location where you would need to place
+/// the noexcept specifier.
+SourceLocation getLocationForNoexceptSpecifier(const FunctionDecl *FuncDecl,
+                                               const SourceManager &SM);
+
 } // namespace tidy::utils::lexer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

 
 Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
                        const LangOptions &LangOpts, bool SkipComments) {
   Token Token;
   Token.setKind(tok::unknown);
 
   Location = Location.getLocWithOffset(-1);
   if (Location.isInvalid())
-      return Token;
 
   auto StartOfFile = SM.getLocForStartOfFile(SM.getFileID(Location));
   while (Location != StartOfFile) {
     Location = Lexer::GetBeginningOfToken(Location, SM, LangOpts);
     if (!Lexer::getRawToken(Location, Token, SM, LangOpts) &&
         (!SkipComments || !Token.is(tok::comment))) {
       break;
     }
return LastMatchAfterTemplate != std::nullopt ? LastMatchAfterTemplate
                                                 : LastMatchBeforeTemplate;
 }
 
 static bool breakAndReturnEnd(const Stmt &S) {
   return isa<CompoundStmt, DeclStmt, NullStmt>(S);
 }
 
 static bool breakAndReturnEndPlus1Token(const Stmt &S) {
-  return isa<Expr, DoStmt, ReturnStmt, BreakStmt, ContinueStmt, GotoStmt, SEHLeaveStmt>(S);
+  return isa<Expr, DoStmt, ReturnStmt, BreakStmt, ContinueStmt, GotoStmt,
+             SEHLeaveStmt>(S);
 }
 
 // Given a Stmt which does not include it's semicolon this method returns the
 // SourceLocation of the semicolon.
 static SourceLocation getSemicolonAfterStmtEndLoc(const SourceLocation &EndLoc,
                                                   const SourceManager &SM,
                                                   const LangOptions &LangOpts) {
 
SourceLocation getUnifiedEndLoc(const Stmt &S, const SourceManager &SM,
 
   const Stmt *LastChild = &S;
   while (!LastChild->children().empty() && !breakAndReturnEnd(*LastChild) &&
          !breakAndReturnEndPlus1Token(*LastChild)) {
     for (const Stmt *Child : LastChild->children())
       LastChild = Child;
   }
 
-  if (!breakAndReturnEnd(*LastChild) &&
-      breakAndReturnEndPlus1Token(*LastChild))
+  if (!breakAndReturnEnd(*LastChild) && breakAndReturnEndPlus1Token(*LastChild))
     return getSemicolonAfterStmtEndLoc(S.getEndLoc(), SM, LangOpts);
 
   return S.getEndLoc();
 }
 
+SourceLocation getLocationForNoexceptSpecifier(const FunctionDecl *FuncDecl,
+                                               const SourceManager &SM) {
+  if (!FuncDecl)
+    return {};
+
+  const LangOptions &LangOpts = FuncDecl->getLangOpts();
+
+  if (FuncDecl->getNumParams() == 0) {
+    // Start at the beginning of the function declaration, and find the closing
+    // parenthesis after which we would place the noexcept specifier.
+    Token CurrentToken;
+    SourceLocation CurrentLocation = FuncDecl->getBeginLoc();
+    while (!Lexer::getRawToken(CurrentLocation, CurrentToken, SM, LangOpts,
+                               true)) {
+      if (CurrentToken.is(tok::r_paren))
+        return CurrentLocation.getLocWithOffset(1);
+
+      CurrentLocation = CurrentToken.getEndLoc();
+    }
+
+    // Failed to find the closing parenthesis, so just return an invalid
+    // SourceLocation.
+    return {};
+  }
+
+  // FunctionDecl with parameters
+  const SourceLocation NoexceptLoc =
+      FuncDecl->getParamDecl(FuncDecl->getNumParams() - 1)->getEndLoc();
+  if (NoexceptLoc.isValid())
+    return Lexer::findLocationAfterToken(NoexceptLoc, tok::r_paren, SM,
+                                         LangOpts, true);
+
+  return {};
+}
+
 } // namespace clang::tidy::utils::lexer

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`modernize-type-traits
   Converts standard library type traits of the form ``traits<...>::type`` and
   ``traits<...>::value`` into ``traits_t<...>`` and ``traits_v<...>`` respectively.
 
 - New :doc:`performance-avoid-endl
   <clang-tidy/checks/performance/avoid-endl>` check.
 
   Finds uses of ``std::endl`` on streams and replaces them with ``'\n'``.
 
+- New :doc:`performance-noexcept-destructor
+  <clang-tidy/checks/performance/noexcept-destructor>` check.
+
+  Finds user declared destructors which are not ``noexcept``.
+
+- New :doc:`performance-noexcept-swap
+  <clang-tidy/checks/performance/noexcept-swap>` check.
+
+  Finds user declared swap functions which are not ``noexcept``.
+
 - New :doc:`readability-avoid-unconditional-preprocessor-if
   <clang-tidy/checks/readability/avoid-unconditional-preprocessor-if>` check.
 
   Finds code blocks that are constantly enabled or disabled in preprocessor
   directives by analyzing ``#if`` conditions, such as ``#if 0`` and
   ``#if 1``, etc.
 
 - New :doc:`readability-operators-representation
   <clang-tidy/checks/readability/operators-representation>` check.
 
   Enforces consistent token representation for invoked binary, unary and
   overloaded operators in C++ code.
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc24-c
   <clang-tidy/checks/cert/msc24-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cert-msc33-c
   <clang-tidy/checks/cert/msc33-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
+- New alias :doc:`cppcoreguidelines-noexcept-destructor
+  <clang-tidy/checks/cppcoreguidelines/noexcept-destructor>` to
+  :doc`performance-noexcept-destructor
+  <clang-tidy/checks/performance/noexcept-destructor>` was added.
+
+- New alias :doc:`cppcoreguidelines-noexcept-move-operations
+  <clang-tidy/checks/cppcoreguidelines/noexcept-move-operations>` to
+  :doc`performance-noexcept-move-constructor
+  <clang-tidy/checks/performance/noexcept-move-constructor>` was added.
+
+- New alias :doc:`cppcoreguidelines-noexcept-swap
+  <clang-tidy/checks/cppcoreguidelines/noexcept-swap>` to
+  :doc`performance-noexcept-swap
+  <clang-tidy/checks/performance/noexcept-swap>` was added.
+
 - New alias :doc:`cppcoreguidelines-use-default-member-init
   <clang-tidy/checks/cppcoreguidelines/use-default-member-init>` to
   :doc:`modernize-use-default-member-init
   <clang-tidy/checks/modernize/use-default-member-init>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
- Improved :doc:`readability-redundant-string-cstr
   arguments to ``std::print``, ``std::format`` or other functions listed in
   the ``StringParameterFunction`` check option.
 
 - Improved :doc:`readability-static-accessed-through-instance
   <clang-tidy/checks/readability/static-accessed-through-instance>` check to
   support unscoped enumerations through instances and fixed usage of anonymous
   structs or classes.
 
 Removed checks
 ^^^^^^^^^^^^^^
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to clang-include-fixer

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-destructor.rst

+.. title:: clang-tidy - cppcoreguidelines-noexcept-destructor
+.. meta::
+   :http-equiv=refresh: 5;URL=../performance/noexcept-destructor.html
+
+cppcoreguidelines-noexcept-destructor
+=====================================
+
+This check implements `C.37 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c37-make-destructors-noexcept>`_
+from the CppCoreGuidelines.
+
+The cppcoreguidelines-noexcept-destructor check is an alias, please see
+`performance-noexcept-destructor <../performance/noexcept-destructor.html>`_
+for more information.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-move-operations.rst

+.. title:: clang-tidy - cppcoreguidelines-noexcept-move-operations
+.. meta::
+   :http-equiv=refresh: 5;URL=../performance/noexcept-move-constructor.html
+
+cppcoreguidelines-noexcept-move-operations
+==========================================
+
+This check implements `C.66 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c66-make-move-operations-noexcept>`_
+from the CppCoreGuidelines.
+
+The cppcoreguidelines-noexcept-move-operations check is an alias, please see
+`performance-noexcept-move-constructor <../performance/noexcept-move-constructor.html>`_
+for more information.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/noexcept-swap.rst

+.. title:: clang-tidy - cppcoreguidelines-noexcept-swap
+.. meta::
+   :http-equiv=refresh: 5;URL=../performance/noexcept-swap.html
+
+cppcoreguidelines-noexcept-swap
+===============================
+
+This check implements `C.83 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c83-for-value-like-types-consider-providing-a-noexcept-swap-function>`_
+, `C.84 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c84-a-swap-function-must-not-fail>`_
+and `C.85 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c85-make-swap-noexcept>`_
+from the CppCoreGuidelines.
+
+The cppcoreguidelines-noexcept-swap check is an alias, please see
+`performance-noexcept-swap <../performance/noexcept-swap.html>`_
+for more information.

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

.. csv-table::
    `cppcoreguidelines-avoid-reference-coroutine-parameters <cppcoreguidelines/avoid-reference-coroutine-parameters.html>`_,
    `cppcoreguidelines-init-variables <cppcoreguidelines/init-variables.html>`_, "Yes"
    `cppcoreguidelines-interfaces-global-init <cppcoreguidelines/interfaces-global-init.html>`_,
    `cppcoreguidelines-macro-usage <cppcoreguidelines/macro-usage.html>`_,
    `cppcoreguidelines-misleading-capture-default-by-value <cppcoreguidelines/misleading-capture-default-by-value.html>`_, "Yes"
    `cppcoreguidelines-missing-std-forward <cppcoreguidelines/missing-std-forward.html>`_,
    `cppcoreguidelines-narrowing-conversions <cppcoreguidelines/narrowing-conversions.html>`_,
    `cppcoreguidelines-no-malloc <cppcoreguidelines/no-malloc.html>`_,
    `cppcoreguidelines-owning-memory <cppcoreguidelines/owning-memory.html>`_,
    `cppcoreguidelines-prefer-member-initializer <cppcoreguidelines/prefer-member-initializer.html>`_, "Yes"
    `cppcoreguidelines-pro-bounds-array-to-pointer-decay <cppcoreguidelines/pro-bounds-array-to-pointer-decay.html>`_,
    `cppcoreguidelines-pro-bounds-constant-array-index <cppcoreguidelines/pro-bounds-constant-array-index.html>`_, "Yes"
    `cppcoreguidelines-pro-bounds-pointer-arithmetic <cppcoreguidelines/pro-bounds-pointer-arithmetic.html>`_,
    `cppcoreguidelines-pro-type-const-cast <cppcoreguidelines/pro-type-const-cast.html>`_,
    `cppcoreguidelines-pro-type-cstyle-cast <cppcoreguidelines/pro-type-cstyle-cast.html>`_, "Yes"
    `cppcoreguidelines-pro-type-member-init <cppcoreguidelines/pro-type-member-init.html>`_, "Yes"
    `cppcoreguidelines-pro-type-reinterpret-cast <cppcoreguidelines/pro-type-reinterpret-cast.html>`_,
.. csv-table::
    `performance-implicit-conversion-in-loop <performance/implicit-conversion-in-loop.html>`_,
    `performance-inefficient-algorithm <performance/inefficient-algorithm.html>`_, "Yes"
    `performance-inefficient-string-concatenation <performance/inefficient-string-concatenation.html>`_,
    `performance-inefficient-vector-operation <performance/inefficient-vector-operation.html>`_, "Yes"
    `performance-move-const-arg <performance/move-const-arg.html>`_, "Yes"
    `performance-move-constructor-init <performance/move-constructor-init.html>`_,
    `performance-no-automatic-move <performance/no-automatic-move.html>`_,
    `performance-no-int-to-ptr <performance/no-int-to-ptr.html>`_,
+   `performance-noexcept-destructor <performance/noexcept-destructor.html>`_, "Yes"
    `performance-noexcept-move-constructor <performance/noexcept-move-constructor.html>`_, "Yes"
+   `performance-noexcept-swap <performance/noexcept-swap.html>`_, "Yes"
    `performance-trivially-destructible <performance/trivially-destructible.html>`_, "Yes"
    `performance-type-promotion-in-math-fn <performance/type-promotion-in-math-fn.html>`_, "Yes"
    `performance-unnecessary-copy-initialization <performance/unnecessary-copy-initialization.html>`_, "Yes"
    `performance-unnecessary-value-param <performance/unnecessary-value-param.html>`_, "Yes"
    `portability-restrict-system-includes <portability/restrict-system-includes.html>`_, "Yes"
    `portability-simd-intrinsics <portability/simd-intrinsics.html>`_,
    `portability-std-allocator-const <portability/std-allocator-const.html>`_,
    `readability-avoid-const-params-in-decls <readability/avoid-const-params-in-decls.html>`_, "Yes"
.. csv-table:: Aliases..
    `clang-analyzer-unix.Vfork <clang-analyzer/unix.Vfork.html>`_, `Clang Static Analyzer unix.Vfork <https://clang.llvm.org/docs/analyzer/checkers.html#unix-vfork>`_,
    `clang-analyzer-unix.cstring.BadSizeArg <clang-analyzer/unix.cstring.BadSizeArg.html>`_, `Clang Static Analyzer unix.cstring.BadSizeArg <https://clang.llvm.org/docs/analyzer/checkers.html#unix-cstring-badsizearg>`_,
    `clang-analyzer-unix.cstring.NullArg <clang-analyzer/unix.cstring.NullArg.html>`_, `Clang Static Analyzer unix.cstring.NullArg <https://clang.llvm.org/docs/analyzer/checkers.html#unix-cstring-nullarg>`_,
    `cppcoreguidelines-avoid-c-arrays <cppcoreguidelines/avoid-c-arrays.html>`_, `modernize-avoid-c-arrays <modernize/avoid-c-arrays.html>`_,
    `cppcoreguidelines-avoid-magic-numbers <cppcoreguidelines/avoid-magic-numbers.html>`_, `readability-magic-numbers <readability/magic-numbers.html>`_,
    `cppcoreguidelines-c-copy-assignment-signature <cppcoreguidelines/c-copy-assignment-signature.html>`_, `misc-unconventional-assign-operator <misc/unconventional-assign-operator.html>`_,
    `cppcoreguidelines-explicit-virtual-functions <cppcoreguidelines/explicit-virtual-functions.html>`_, `modernize-use-override <modernize/use-override.html>`_, "Yes"
    `cppcoreguidelines-macro-to-enum <cppcoreguidelines/macro-to-enum.html>`_, `modernize-macro-to-enum <modernize/macro-to-enum.html>`_, "Yes"
+   `cppcoreguidelines-noexcept-destructor <cppcoreguidelines/noexcept-destructor.html>`_, `performance-noexcept-destructor <performance/noexcept-destructor.html>`_, "Yes"
+   `cppcoreguidelines-noexcept-move-operations <cppcoreguidelines/noexcept-move-operations.html>`_, `performance-noexcept-move-constructor <performance/noexcept-move-constructor.html>`_, "Yes"
+   `cppcoreguidelines-noexcept-swap <cppcoreguidelines/noexcept-swap.html>`_, `performance-noexcept-swap <performance/noexcept-swap.html>`_, "Yes"
    `cppcoreguidelines-non-private-member-variables-in-classes <cppcoreguidelines/non-private-member-variables-in-classes.html>`_, `misc-non-private-member-variables-in-classes <misc/non-private-member-variables-in-classes.html>`_,
    `cppcoreguidelines-use-default-member-init <cppcoreguidelines/use-default-member-init.html>`_, `modernize-use-default-member-init <modernize/use-default-member-init.html>`_,
    `fuchsia-header-anon-namespaces <fuchsia/header-anon-namespaces.html>`_, `google-build-namespaces <google/build-namespaces.html>`_,
    `google-readability-braces-around-statements <google/readability-braces-around-statements.html>`_, `readability-braces-around-statements <readability/braces-around-statements.html>`_, "Yes"
    `google-readability-function-size <google/readability-function-size.html>`_, `readability-function-size <readability/function-size.html>`_,
    `google-readability-namespace-comments <google/readability-namespace-comments.html>`_, `llvm-namespace-comment <llvm/namespace-comment.html>`_,
    `hicpp-avoid-c-arrays <hicpp/avoid-c-arrays.html>`_, `modernize-avoid-c-arrays <modernize/avoid-c-arrays.html>`_,
    `hicpp-braces-around-statements <hicpp/braces-around-statements.html>`_, `readability-braces-around-statements <readability/braces-around-statements.html>`_, "Yes"
    `hicpp-deprecated-headers <hicpp/deprecated-headers.html>`_, `modernize-deprecated-headers <modernize/deprecated-headers.html>`_, "Yes"
    `hicpp-explicit-conversions <hicpp/explicit-conversions.html>`_, `google-explicit-constructor <google/explicit-constructor.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/performance/noexcept-destructor.rst

+.. title:: clang-tidy - performance-noexcept-destructor
+
+performance-noexcept-destructor
+===============================
+
+The check flags user-defined destructors marked with ``noexcept(expr)``
+where ``expr`` evaluates to ``false`` (but is not a ``false`` literal itself).
+
+When a destructor is marked as ``noexcept``, it assures the compiler that
+no exceptions will be thrown during the destruction of an object, which
+allows the compiler to perform certain optimizations such as omitting
+exception handling code.

clang-tools-extra/docs/clang-tidy/checks/performance/noexcept-swap.rst

+.. title:: clang-tidy - performance-noexcept-swap
+
+performance-noexcept-swap
+=========================
+
+The check flags user-defined swap functions not marked with ``noexcept`` or
+marked with ``noexcept(expr)`` where ``expr`` evaluates to ``false``
+(but is not a ``false`` literal itself).
+
+When a swap function is marked as ``noexcept``, it assures the compiler that
+no exceptions will be thrown during the swapping of two objects, which allows
+the compiler to perform certain optimizations such as omitting exception
+handling code.

clang-tools-extra/test/clang-tidy/checkers/performance/noexcept-destructor.cpp

+// RUN: %check_clang_tidy %s performance-noexcept-destructor %t -- -- -fexceptions
+
+struct Empty
+{};
+
+struct IntWrapper {
+  int value;
+};
+
+template <typename T>
+struct FalseT {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct TrueT {
+  static constexpr bool value = true;
+};
+
+struct ThrowOnAnything {
+  ThrowOnAnything() noexcept(false);
+  ThrowOnAnything(ThrowOnAnything&&) noexcept(false);
+  ThrowOnAnything& operator=(ThrowOnAnything &&) noexcept(false);
+  ~ThrowOnAnything() noexcept(false);
+};
+
+struct B {
+  static constexpr bool kFalse = false;
+  ~B() noexcept(kFalse);
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+struct D {
+  static constexpr bool kFalse = false;
+  ~D() noexcept(kFalse) = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+template <typename>
+struct E {
+  static constexpr bool kFalse = false;
+  ~E() noexcept(kFalse);
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false'
+};
+
+template <typename>
+struct F {
+  static constexpr bool kFalse = false;
+  ~F() noexcept(kFalse) = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+struct G {
+  ~G() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~G() noexcept  = default;
+
+  ThrowOnAnything field;
+};
+
+void throwing_function() noexcept(false) {}
+
+struct H {
+  ~H() noexcept(noexcept(throwing_function()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+template <typename>
+struct I {
+  ~I() noexcept(noexcept(throwing_function()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+template <typename T> struct TemplatedType {
+  static void f() {}
+};
+
+template <> struct TemplatedType<int> {
+  static void f() noexcept {}
+};
+
+struct J {
+  ~J() noexcept(noexcept(TemplatedType<double>::f()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: noexcept specifier on the destructor evaluates to 'false' [performance-noexcept-destructor]
+};
+
+struct K : public ThrowOnAnything {
+  ~K() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~K() noexcept  = default;
+};
+
+struct InheritFromThrowOnAnything : public ThrowOnAnything
+{};
+
+struct L {
+  ~L() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~L() noexcept  = default;
+
+  InheritFromThrowOnAnything IFF;
+};
+
+struct M : public InheritFromThrowOnAnything {
+  ~M() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~M() noexcept  = default;
+};
+
+struct N : public IntWrapper, ThrowOnAnything {
+  ~N() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~N() noexcept  = default;
+};
+
+struct O : virtual IntWrapper, ThrowOnAnything {
+  ~O() = default;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: destructors should be marked noexcept [performance-noexcept-destructor]
+  // CHECK-FIXES: ~O() noexcept  = default;
+};
+
+class OK {};
+
+struct OK1 {
+  ~OK1() noexcept;
+};
+
+struct OK2 {
+  static constexpr bool kTrue = true;
+
+  ~OK2() noexcept(true) {}
+};
+
+struct OK4 {
+  ~OK4() noexcept(false) {}
+};
+
+struct OK3 {
+  ~OK3() = default;
+};
+
+struct OK5 {
+  ~OK5() noexcept(true) = default;
+};
+
+struct OK6 {
+  ~OK6() = default;
+};
+
+template <typename>
+struct OK7 {
+  ~OK7() = default;
+};
+
+template <typename>
+struct OK8 {
+  ~OK8() noexcept = default;
+};
+
+template <typename>
+struct OK9 {
+  ~OK9() noexcept(true) = default;
+};
+
+template <typename>
+struct OK10 {
+  ~OK10() noexcept(false) = default;
+};
+
+template <typename>
+struct OK11 {
+  ~OK11() = delete;
+};
+
+void noexcept_function() noexcept {}
+
+struct OK12 {
+  ~OK12() noexcept(noexcept(noexcept_function()));
+};
+
+struct OK13 {
+  ~OK13() noexcept(noexcept(noexcept_function())) = default;
+};
+
+template <typename>
+struct OK14 {
+  ~OK14() noexcept(noexcept(TemplatedType<int>::f()));
+};
+
+struct OK15 {
+  ~OK15() = default;
+
+  int member;
+};
+
+template <typename>
+struct OK16 {
+  ~OK16() = default;
+
+  int member;
+};
+
+struct OK17 {
+  ~OK17() = default;
+
+  OK empty_field;
+};
+
+template <typename>
+struct OK18 {
+  ~OK18() = default;
+
+  OK empty_field;
+};
+
+struct OK19 : public OK {
+  ~OK19() = default;
+};
+
+struct OK20 : virtual OK {
+  ~OK20() = default;
+};
+
+template <typename T>
+struct OK21 : public T {
+  ~OK21() = default;
+};
+
+template <typename T>
+struct OK22 : virtual T {
+  ~OK22() = default;
+};
+
+template <typename T>
+struct OK23 {
+  ~OK23() = default;
+
+  T member;
+};
+
+void testTemplates() {
+  OK21<Empty> value(OK21<Empty>{});
+  value = OK21<Empty>{};
+
+  OK22<Empty> value2{OK22<Empty>{}};
+  value2 = OK22<Empty>{};
+
+  OK23<Empty> value3{OK23<Empty>{}};
+  value3 =OK23<Empty>{};
+}
+
+struct OK24 : public Empty, OK1 {
+  ~OK24() = default;
+};
+
+struct OK25 : virtual Empty, OK1 {
+  ~OK25() = default;
+};
+
+struct OK26 : public Empty, IntWrapper {
+  ~OK26() = default;
+};
+
+template <typename T>
+struct OK27 : public T {
+  ~OK27() = default;
+};
+
+template <typename T>
+struct OK28 : virtual T {
+  ~OK28() = default;
+};
+
+template <typename T>
+struct OK29 {
+  ~OK29() = default;
+
+  T member;
+};
+
+struct OK30 {
+  ~OK30() noexcept(TrueT<OK30>::value) = default;
+};
+
+template <typename>
+struct OK31 {
+  ~OK31() noexcept(TrueT<int>::value) = default;
+};
+
+struct OK32 {
+  ~OK32();
+};
+
+template <typename>
+struct OK33 {
+  ~OK33();
+};
+
+struct OK34 {
+  ~OK34() {}
+};
+
+template <typename>
+struct OK35 {
+  ~OK35() {}
+};

clang-tools-extra/test/clang-tidy/checkers/performance/noexcept-move-constructor.cpp

struct FalseT {
   static constexpr bool value = false;
 };
 
 template <typename T>
 struct TrueT {
   static constexpr bool value = true;
 };
 
-struct ThrowingMoveConstructor
-{
-  ThrowingMoveConstructor() = default;
-  ThrowingMoveConstructor(ThrowingMoveConstructor&&) noexcept(false) {
-  }
-  ThrowingMoveConstructor& operator=(ThrowingMoveConstructor &&) noexcept(false) {
-    return *this;
-  }
+struct ThrowOnAnything {
+  ThrowOnAnything() noexcept(false);
+  ThrowOnAnything(ThrowOnAnything&&) noexcept(false);
+  ThrowOnAnything& operator=(ThrowOnAnything &&) noexcept(false);
+  ~ThrowOnAnything() noexcept(false);
 };
 
 class A {
   A(A &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: A(A &&) noexcept ;
   A &operator=(A &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: A &operator=(A &&) noexcept ;
 };
 
 struct B {
   static constexpr bool kFalse = false;
   B(B &&) noexcept(kFalse);
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
+  B &operator=(B &&) noexcept(kFalse);
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
 template <typename>
-struct C
-{
+struct C {
   C(C &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: C(C &&) noexcept ;
   C& operator=(C &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: C& operator=(C &&) noexcept ;
 };
 
-struct D
-{
+struct D {
   static constexpr bool kFalse = false;
   D(D &&) noexcept(kFalse) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   D& operator=(D &&) noexcept(kFalse) = default;
-  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false'
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
 template <typename>
-struct E
-{
+struct E {
   static constexpr bool kFalse = false;
   E(E &&) noexcept(kFalse);
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   E& operator=(E &&) noexcept(kFalse);
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false'
 };
 
 template <typename>
-struct F
-{
+struct F {
   static constexpr bool kFalse = false;
   F(F &&) noexcept(kFalse) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   F& operator=(F &&) noexcept(kFalse) = default;
-  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false'
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
 struct G {
   G(G &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: G(G &&)  noexcept = default;
   G& operator=(G &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: G& operator=(G &&)  noexcept = default;
 
-  ThrowingMoveConstructor field;
+  ThrowOnAnything field;
 };
 
 void throwing_function() noexcept(false) {}
 
 struct H {
   H(H &&) noexcept(noexcept(throwing_function()));
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   H &operator=(H &&) noexcept(noexcept(throwing_function()));
-  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false'
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
 template <typename>
 struct I {
   I(I &&) noexcept(noexcept(throwing_function()));
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   I &operator=(I &&) noexcept(noexcept(throwing_function()));
-  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false'
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
-template <typename TemplateType> struct TemplatedType {
+template <typename T> struct TemplatedType {
   static void f() {}
 };
 
 template <> struct TemplatedType<int> {
   static void f() noexcept {}
 };
 
 struct J {
   J(J &&) noexcept(noexcept(TemplatedType<double>::f()));
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [performance-noexcept-move-constructor]
   J &operator=(J &&) noexcept(noexcept(TemplatedType<double>::f()));
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: noexcept specifier on the move assignment operator evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
-struct K : public ThrowingMoveConstructor {
+struct K : public ThrowOnAnything {
   K(K &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: K(K &&)  noexcept = default;
   K &operator=(K &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: K &operator=(K &&)  noexcept = default;
 };
 
-struct InheritFromThrowingMoveConstrcutor : public ThrowingMoveConstructor
+struct InheritFromThrowOnAnything : public ThrowOnAnything
 {};
 
 struct L {
   L(L &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: L(L &&)  noexcept = default;
   L &operator=(L &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: L &operator=(L &&)  noexcept = default;
 
-  InheritFromThrowingMoveConstrcutor IFF;
+  InheritFromThrowOnAnything IFF;
 };
 
-struct M : public InheritFromThrowingMoveConstrcutor {
+struct M : public InheritFromThrowOnAnything {
   M(M &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: M(M &&)  noexcept = default;
   M &operator=(M &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: M &operator=(M &&)  noexcept = default;
 };
 
-struct N : public IntWrapper, ThrowingMoveConstructor {
+struct N : public IntWrapper, ThrowOnAnything {
   N(N &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: N(N &&)  noexcept = default;
   N &operator=(N &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: N &operator=(N &&)  noexcept = default;
 };
 
-struct O : virtual IntWrapper, ThrowingMoveConstructor {
+struct O : virtual IntWrapper, ThrowOnAnything {
   O(O &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: O(O &&)  noexcept = default;
   O &operator=(O &&) = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor]
+  // CHECK-FIXES: O &operator=(O &&)  noexcept = default;
 };
 
 class OK {};
 
 void f() {
   OK a;
   a = OK();
 }
 
-class OK1 {
-public:
-  OK1();
+struct OK1 {
   OK1(const OK1 &);
   OK1(OK1 &&) noexcept;
   OK1 &operator=(OK1 &&) noexcept;
   void f();
   void g() noexcept;
 };
 
 struct OK2 {
   static constexpr bool kTrue = true;
 
   OK2(OK2 &&) noexcept(true) {}
   OK2 &operator=(OK2 &&) noexcept(kTrue) { return *this; }
 };
 
-struct OK3 {
-  OK3(OK3 &&) noexcept(false) {}
-  OK3 &operator=(OK3 &&) = delete;
+struct OK4 {
+  OK4(OK4 &&) noexcept(false) {}
+  OK4 &operator=(OK4 &&) = delete;
 };
 
-struct OK4 {
-  OK4(OK4 &&) noexcept = default;
-  OK4 &operator=(OK4 &&) noexcept = default;
+struct OK3 {
+  OK3(OK3 &&) noexcept = default;
+  OK3 &operator=(OK3 &&) noexcept = default;
 };
 
 struct OK5 {
   OK5(OK5 &&) noexcept(true) = default;
   OK5 &operator=(OK5 &&) noexcept(true) = default;
 };
 
 struct OK6 {
struct OK12 {
   OK12 &operator=(OK12 &&) noexcept(noexcept(noexcept_function));
 };
 
 struct OK13 {
   OK13(OK13 &&) noexcept(noexcept(noexcept_function)) = default;
   OK13 &operator=(OK13 &&) noexcept(noexcept(noexcept_function)) = default;
 };
 
-template <typename> struct OK14 {
+template <typename>
+struct OK14 {
   OK14(OK14 &&) noexcept(noexcept(TemplatedType<int>::f()));
   OK14 &operator=(OK14 &&) noexcept(noexcept(TemplatedType<int>::f()));
 };
 
 struct OK15 {
   OK15(OK15 &&) = default;
   OK15 &operator=(OK15 &&) = default;
 
   int member;
 };
 
 template <typename>
 struct OK16 {
   OK16(OK16 &&) = default;
   OK16 &operator=(OK16 &&) = default;
 
   int member;
 };
 
-struct OK17
-{
+struct OK17 {
   OK17(OK17 &&) = default;
   OK17 &operator=(OK17 &&) = default;
+
   OK empty_field;
 };
 
 template <typename>
-struct OK18
-{
+struct OK18 {
   OK18(OK18 &&) = default;
   OK18 &operator=(OK18 &&) = default;
 
   OK empty_field;
 };
 
-struct OK19 : public OK
-{
+struct OK19 : public OK {
   OK19(OK19 &&) = default;
   OK19 &operator=(OK19 &&) = default;
 };
 
-struct OK20 : virtual OK
-{
+struct OK20 : virtual OK {
   OK20(OK20 &&) = default;
   OK20 &operator=(OK20 &&) = default;
 };
 
 template <typename T>
-struct OK21 : public T
-{
+struct OK21 : public T {
   OK21() = default;
   OK21(OK21 &&) = default;
   OK21 &operator=(OK21 &&) = default;
 };
 
 template <typename T>
-struct OK22 : virtual T
-{
+struct OK22 : virtual T {
   OK22() = default;
   OK22(OK22 &&) = default;
   OK22 &operator=(OK22 &&) = default;
 };
 
 template <typename T>
 struct OK23 {
-  OK23()= default;
+  OK23() = default;
   OK23(OK23 &&) = default;
   OK23 &operator=(OK23 &&) = default;
 
   T member;
 };
 
 void testTemplates() {
   OK21<Empty> value(OK21<Empty>{});

 };
 
 struct OK26 : public Empty, IntWrapper {
   OK26(OK26 &&) = default;
   OK26 &operator=(OK26 &&) = default;
 };
 
 template <typename T>
-struct OK27 : public T
-{
+struct OK27 : public T {
   OK27(OK27 &&) = default;
   OK27 &operator=(OK27 &&) = default;
 };
 
 template <typename T>
-struct OK28 : virtual T
-{
+struct OK28 : virtual T {
   OK28(OK28 &&) = default;
   OK28 &operator=(OK28 &&) = default;
 };
 
 template <typename T>
 struct OK29 {
   OK29(OK29 &&) = default;
   OK29 &operator=(OK29 &&) = default;

clang-tools-extra/test/clang-tidy/checkers/performance/noexcept-swap.cpp

+// RUN: %check_clang_tidy %s performance-noexcept-swap %t -- -- -fexceptions
+
+void throwing_function() noexcept(false);
+void noexcept_function() noexcept;
+
+template <typename>
+struct TemplateNoexceptWithInt {
+  static void f() {}
+};
+
+template <>
+struct TemplateNoexceptWithInt<int> {
+  static void f() noexcept {}
+};
+
+class A {
+  void swap(A &);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+  // CHECK-FIXES: void swap(A &) noexcept ;
+};
+
+void swap(A &, A &);
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+// CHECK-FIXES: void swap(A &, A &) noexcept ;
+
+struct B {
+  static constexpr bool kFalse = false;
+  void swap(B &) noexcept(kFalse);
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+};
+
+void swap(B &, B &) noexcept(B::kFalse);
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+
+template <typename>
+struct C {
+  void swap(C&);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+  // CHECK-FIXES: void swap(C&) noexcept ;
+};
+
+template <typename T>
+void swap(C<T>&, C<T>&);
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+// CHECK-FIXES: void swap(C<T>&, C<T>&) noexcept ;
+void swap(C<int>&, C<int>&);
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+// CHECK-FIXES: void swap(C<int>&, C<int>&) noexcept ;
+
+template <typename>
+struct D {
+  static constexpr bool kFalse = false;
+  void swap(D &) noexcept(kFalse);
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+};
+
+template <typename T>
+void swap(D<T> &, D<T> &) noexcept(D<T>::kFalse);
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+void swap(D<int> &, D<int> &) noexcept(D<int>::kFalse);
+// CHECK-MESSAGES: :[[@LINE-1]]:40: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+
+struct E {
+  void swap(E &) noexcept(noexcept(throwing_function()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+};
+
+void swap(E &, E &) noexcept(noexcept(throwing_function()));
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+
+template <typename>
+struct F {
+  void swap(F &) noexcept(noexcept(throwing_function()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+};
+
+template <typename T>
+void swap(F<T> &, F<T> &) noexcept(noexcept(throwing_function()));
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+void swap(F<int> &, F<int> &) noexcept(noexcept(throwing_function()));
+// CHECK-MESSAGES: :[[@LINE-1]]:40: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+
+struct G {
+  void swap(G &) noexcept(noexcept(TemplateNoexceptWithInt<double>::f()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+};
+
+void swap(G &, G &) noexcept(noexcept(TemplateNoexceptWithInt<double>::f()));
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: noexcept specifier on swap function evaluates to 'false' [performance-noexcept-swap]
+
+class OK {};
+
+struct OK1 {
+  void swap(OK1 &) noexcept;
+};
+
+void swap(OK1 &, OK1 &) noexcept;
+
+struct OK2 {
+  static constexpr bool kTrue = true;
+  void swap(OK2 &) noexcept(kTrue) {}
+};
+
+void swap(OK2 &, OK2 &) noexcept(OK2::kTrue);
+
+struct OK3 {
+    void swap(OK3 &) = delete;
+};
+
+void swap(OK3 &, OK3 &) = delete;
+
+struct OK4 {
+  void swap(OK4 &) noexcept(false);
+};
+
+void swap(OK4 &, OK4 &) noexcept(false);
+
+struct OK5 {
+  void swap(OK5 &) noexcept(true);
+};
+
+void swap(OK5 &, OK5 &)noexcept(true);
+
+struct OK12 {
+  void swap(OK12 &) noexcept(noexcept(noexcept_function()));
+};
+
+void swap(OK12 &, OK12 &) noexcept(noexcept(noexcept_function()));
+
+struct OK13 {
+  void swap(OK13 &) noexcept(noexcept(TemplateNoexceptWithInt<int>::f()));
+};
+
+void swap(OK13 &, OK13 &) noexcept(noexcept(TemplateNoexceptWithInt<int>::f()));
+
+template <typename>
+class OK14 {};
+
+template <typename>
+struct OK15 {
+  void swap(OK15 &) noexcept;
+};
+
+template <typename T>
+void swap(OK15<T> &, OK15<T> &) noexcept;
+void swap(OK15<int> &, OK15<int> &) noexcept;
+
+template <typename>
+struct OK16 {
+  static constexpr bool kTrue = true;
+  void swap(OK16 &) noexcept(kTrue);
+};
+
+// FIXME: This gives a warning, but it should be OK.
+//template <typename T>
+//void swap(OK16<T> &, OK16<T> &) noexcept(OK16<T>::kTrue);
+template <typename T>
+void swap(OK16<int> &, OK16<int> &) noexcept(OK16<int>::kTrue);
+
+template <typename>
+struct OK17 {
+    void swap(OK17 &) = delete;
+};
+
+template <typename T>
+void swap(OK17<T> &, OK17<T> &) = delete;
+void swap(OK17<int> &, OK17<int> &) = delete;
+
+template <typename>
+struct OK18 {
+  void swap(OK18 &) noexcept(false);
+};
+
+template <typename T>
+void swap(OK18<T> &, OK18<T> &) noexcept(false);
+void swap(OK18<int> &, OK18<int> &) noexcept(false);
+
+template <typename>
+struct OK19 {
+  void swap(OK19 &) noexcept(true);
+};
+
+template <typename T>
+void swap(OK19<T> &, OK19<T> &)noexcept(true);
+void swap(OK19<int> &, OK19<int> &)noexcept(true);
+
+template <typename>
+struct OK20 {
+  void swap(OK20 &) noexcept(noexcept(noexcept_function()));
+};
+
+template <typename T>
+void swap(OK20<T> &, OK20<T> &) noexcept(noexcept(noexcept_function()));
+void swap(OK20<int> &, OK20<int> &) noexcept(noexcept(noexcept_function()));
+
+template <typename>
+struct OK21 {
+  void swap(OK21 &) noexcept(noexcept(TemplateNoexceptWithInt<int>::f()));
+};
+
+template <typename T>
+void swap(OK21<T> &, OK21<T> &) noexcept(noexcept(TemplateNoexceptWithInt<int>::f()));
+void swap(OK21<int> &, OK21<int> &) noexcept(noexcept(TemplateNoexceptWithInt<int>::f()));