[clang-tidy] Add FixItHint for performance-noexcept-move-constructor

[aaron.ballman]

clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

57

Does getParamDecl()->getEndLoc() not give the correct answer?

test/clang-tidy/performance-noexcept-move-constructor-fix.cpp

8

This style of test is a bit loose as it will pass even if the fix-it replaces the entire constructor with the noexcept token.

[zinovy.nis]

clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

57

Unfortunately not. In that case

C_1(C_1&& a) :C_1(5) {} turns into C_1(C_1&& a noexcept) :C_1(5) {}. instead of C_1(C_1&& a) noexcept :C_1(5) {}

[zinovy.nis]

• Fixed tests.

[aaron.ballman]

LGTM!

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 "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/FixIt.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {
if (const auto *Decl = Result.Nodes.getNodeAs<CXXMethodDecl>("decl")) {
     }
 
     const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
 
     if (isUnresolvedExceptionSpec(ProtoType->getExceptionSpecType()))
       return;
 
     if (!isNoexceptExceptionSpec(ProtoType->getExceptionSpecType())) {
+      auto Diag =
           diag(Decl->getLocation(), "move %0s should be marked noexcept")
           << MethodType;
-      // FIXME: Add a fixit.
+      // Add FixIt hints.
+      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);
+      if (NoexceptLoc.isValid())
+        Diag << FixItHint::CreateInsertion(NoexceptLoc, " noexcept ");
       return;
     }
 
     // Don't complain about nothrow(false), but complain on nothrow(expr)
     // where expr evaluates to false.
     if (ProtoType->canThrow() == CT_Can) {
       Expr *E = ProtoType->getNoexceptExpr();
       E = E->IgnoreImplicit();

test/clang-tidy/performance-noexcept-move-constructor-fix.cpp

+// RUN: %check_clang_tidy %s performance-noexcept-move-constructor %t
+
+struct C_1 {
+ ~C_1() {}
+ C_1(int a) {}
+ C_1(C_1&& a) :C_1(5) {}
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ C_1& operator=(C_1&&) { return *this; }
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+struct C_2 {
+ ~C_2() {}
+ C_2(C_2&& a);
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ C_2& operator=(C_2&&);
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+C_2::C_2(C_2&& a) {}
+// CHECK-FIXES:{{.*}}noexcept{{.*}}
+C_2& C_2::operator=(C_2&&) { return *this; }
+// CHECK-FIXES:{{.*}}noexcept{{.*}}
+
+struct C_4 {
+ ~C_4() {}
+ C_4(C_4&& a);
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ C_4& operator=(C_4&& a);
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+C_4::C_4(C_4&& a) = default;
+// CHECK-FIXES:{{.*}}noexcept{{.*}}
+C_4& C_4::operator=(C_4&& a) = default;
+// CHECK-FIXES:{{.*}}noexcept{{.*}}
+
+template <class T>
+struct C_5 {
+ C_5(C_5<T>&&) {}
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ ~C_5() {}
+ C_5& operator=(C_5&& a) = default;
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+template <class T>
+struct C_6 {
+ C_6(C_6<T>&&) {}
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ ~C_6() {}
+ auto operator=(C_6&& a)->C_6<T> = default;
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+template <class T>
+struct C_7 {
+ C_7(C_7<T>&&) {}
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+ ~C_7() {}
+ auto operator=(C_7&& a)->C_7<T>;
+ // CHECK-FIXES:{{.*}}noexcept{{.*}}
+};
+
+template <class T>
+auto C_7<T>::operator=(C_7<T>&& a) -> C_7<T> {}
+// CHECK-FIXES:{{.*}}noexcept{{.*}}