[clang-tidy] Fix false-positives in performanc-noexcept-swap

[PiotrZSL]

Summary

Enforce a stricter match with the swap function signature, eliminating false-positives.

Fixes: #64303

[carlosgalvezp]

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

19–20

Would be good to add a small comment summarizing what signatures this block of code matches, for easier readability.

[PiotrZSL]

Rebase, add comments, make more strict for method (must be non-const)

[carlosgalvezp]

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

31

Duplicate void, remove

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

215

Could we also test:

friend void swap(T&, T&)?

[PiotrZSL]

Fix comments + add test with friend

[PiotrZSL]

Remove space

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

 
 using namespace clang::ast_matchers;
 
 // FixItHint - comment added to fix list.rst generation in add_new_check.py.
 // Do not remove. Fixes are generated in base class.
 
 namespace clang::tidy::performance {
 
 void NoexceptSwapCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      functionDecl(unless(isDeleted()), hasName("swap")).bind(BindFuncDeclName),
+
+  // Match non-const method with single argument that is non-const reference to
+  // a class type that owns method and return void.
+  // Matches: void Class::swap(Class&)
+  auto MethodMatcher = cxxMethodDecl(
+      parameterCountIs(1U), unless(isConst()), returns(voidType()),
+      hasParameter(0, hasType(qualType(hasCanonicalType(
+                          qualType(unless(isConstQualified()),
+                                   references(namedDecl().bind("class"))))))),
+      ofClass(equalsBoundNode("class")));
+
+  // Match function with 2 arguments, both are non-const references to same type
+  // and return void.
+  // Matches: void swap(Type&, Type&)
+  auto FunctionMatcher = allOf(
+      unless(cxxMethodDecl()), parameterCountIs(2U), returns(voidType()),
+      hasParameter(
+          0, hasType(qualType(hasCanonicalType(
+                 qualType(unless(isConstQualified()), references(qualType()))
+                     .bind("type"))))),
+      hasParameter(1, hasType(qualType(hasCanonicalType(
+                          qualType(equalsBoundNode("type")))))));
+  Finder->addMatcher(functionDecl(unless(isDeleted()), hasName("swap"),
+                                  anyOf(MethodMatcher, FunctionMatcher))
+                         .bind(BindFuncDeclName),
                      this);
 }
 
 DiagnosticBuilder
 NoexceptSwapCheck::reportMissingNoexcept(const FunctionDecl *FuncDecl) {
   return diag(FuncDecl->getLocation(), "swap functions should "
                                        "be marked noexcept");
 }
 
 void NoexceptSwapCheck::reportNoexceptEvaluatedToFalse(
     const FunctionDecl *FuncDecl, const Expr *NoexceptExpr) {
   diag(NoexceptExpr->getExprLoc(),
        "noexcept specifier on swap function evaluates to 'false'");
 }
 
 } // namespace clang::tidy::performance

clang-tools-extra/docs/ReleaseNotes.rst

 - Improved :doc:`llvm-namespace-comment
   <clang-tidy/checks/llvm/namespace-comment>` check to provide fixes for
   ``inline`` namespaces in the same format as :program:`clang-format`.
 
 - Improved :doc:`modernize-loop-convert
   <clang-tidy/checks/modernize/loop-convert>` to support for-loops with
   iterators initialized by free functions like ``begin``, ``end``, or ``size``.
 
+- Improved :doc:`performanc-noexcept-swap
+  <clang-tidy/checks/performance/noexcept-swap>` check to enforce a stricter
+  match with the swap function signature, eliminating false-positives.
+
 - Improved the :doc:`readability-identifier-naming
   <clang-tidy/checks/readability/identifier-naming>` check to emit proper
   warnings when a type forward declaration precedes its definition.
 
 Removed checks
 ^^^^^^^^^^^^^^
 
 Improvements to include-fixer

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

 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()));
+
+namespace PR64303 {
+  void swap();
+  void swap(int&, bool&);
+  void swap(int&, int&, int&);
+  void swap(int&);
+
+  struct Test {
+    void swap();
+    void swap(Test&, Test&);
+    void swap(int&);
+    static void swap(int&, int&);
+
+    friend void swap(Test&, Test&);
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: swap functions should be marked noexcept [performance-noexcept-swap]
+  };
+}