[clang-tidy] diagnose possibiltiy to add 'noexcept' in modernize-use-noexcept

[JonasToth]

Summary

This patch utilizes the refactored ExceptionAnalyzer for
modernize-use-noexcept to diagnose possibilties to introduce noexcept
if there is no exception specification at all.
A follow-up patch will then implement the code-transformation if this patch
is useful.

[JonasToth]

• rebase to current refactoring

[lebedev.ri]

Hmm, i think this diff is incorrect. Doesn't it also include the changes from D57100 ?

[JonasToth]

In D57108#1369161, @lebedev.ri wrote:

Hmm, i think this diff is incorrect. Doesn't it also include the changes from D57100 ?

yup, needs constant rebasing, i will do a final rebase once the other refactring is in.

[JonasToth]

• rebase to latest patch

[JonasToth]

• Merge branch 'master' into feature-introduce-noexcept

[lebedev.ri]

Please add tests with lambdas,

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

5–6

Unused functions.
I suspect if the first one called, we can't be optimistic, and say that noexcept can be added?

[MyDeveloperDay]

clang-tidy/modernize/UseNoexceptCheck.h

1

Nit: sorry OCD kicking in... space after tidy and before first -

[baloghadamsoftware]

Great! However, I would rename the test files: modernize-use-noexcept-opt.cpp is inaccurate since there are multiple options, it could be e.g. modernize-use-noexcept-dont-use-noexcept-false.cpp. modernize-use-noexcept-new-noexcept.cpp is a bit misleading because of the new which is a valid C++ keyword. modernize-use-noexcept-add-missing-noexcept.cpp sounds better for me.

[baloghadamsoftware]

Ping! Any news regarding this patch?

[JonasToth]

In D57108#1433087, @baloghadamsoftware wrote:

Ping! Any news regarding this patch?

Its on the todolist, but i currently have many things to do in my real life, so no time for clang-tidy development :(

clang-tidy/modernize/UseNoexceptCheck.h

 //===--- UseNoexceptCheck.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_MODERNIZE_USE_NOEXCEPT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H
 
 #include "../ClangTidy.h"
+#include "../utils/ExceptionAnalyzer.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// \brief Replace dynamic exception specifications, with
 /// `noexcept` (or user-defined macro) or `noexcept(false)`.
 /// \code

 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;
+  const bool UseNoexceptFalse;
+  const bool AddMissingNoexcept;
+  utils::ExceptionAnalyzer Analyzer;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H

clang-tidy/modernize/UseNoexceptCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseNoexceptCheck::UseNoexceptCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       NoexceptMacro(Options.get("ReplacementString", "")),
-      UseNoexceptFalse(Options.get("UseNoexceptFalse", true)) {}
+      UseNoexceptFalse(Options.get("UseNoexceptFalse", true)),
+      AddMissingNoexcept(Options.get("AddMissingNoexcept", false)) {}
 
 void UseNoexceptCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ReplacementString", NoexceptMacro);
   Options.store(Opts, "UseNoexceptFalse", UseNoexceptFalse);
+  Options.store(Opts, "AddMissingNoexcept", AddMissingNoexcept);
 }
 
 void UseNoexceptCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   Finder->addMatcher(
       functionDecl(
void UseNoexceptCheck::registerMatchers(MatchFinder *Finder) {
 
   Finder->addMatcher(
       parmVarDecl(anyOf(hasType(pointerType(pointee(parenType(innerType(
                             functionProtoType(hasDynamicExceptionSpec())))))),
                         hasType(memberPointerType(pointee(parenType(innerType(
                             functionProtoType(hasDynamicExceptionSpec()))))))))
           .bind("parmVarDecl"),
       this);
+
+  if (AddMissingNoexcept)
+    Finder->addMatcher(
+        functionDecl(allOf(hasBody(stmt()),
+                           unless(anyOf(isNoThrow(), hasDynamicExceptionSpec(),
+                                        isImplicit()))))
+            .bind("potentialNoexcept"),
+        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")) {
FnTy = ParmDecl->getType()
                ->getAs<FunctionProtoType>();
 
     if (const auto *TSI = ParmDecl->getTypeSourceInfo())
       Range = TSI->getTypeLoc()
                   .getNextTypeLoc()
                   .IgnoreParens()
                   .castAs<FunctionProtoTypeLoc>()
                   .getExceptionSpecRange();
+  } else if (const auto *PotentialNoexcept =
+                 Result.Nodes.getNodeAs<FunctionDecl>("potentialNoexcept")) {
+    if (!Analyzer.throwsException(PotentialNoexcept) &&
+        PotentialNoexcept->getBeginLoc().isValid())
+      diag(PotentialNoexcept->getBeginLoc(),
+           "this function can not throw an exception, consider adding "
+           "'noexcept'");
+    return;
   }
   CharSourceRange CRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Range), *Result.SourceManager,
       Result.Context->getLangOpts());
 
   assert(FnTy && "FunctionProtoType is null.");
   bool IsNoThrow = FnTy->isNothrow();
   StringRef ReplacementStr =
       IsNoThrow
           ? NoexceptMacro.empty() ? "noexcept" : NoexceptMacro.c_str()
-          : NoexceptMacro.empty()
-                ? (DtorOrOperatorDel || UseNoexceptFalse) ? "noexcept(false)"
-                                                          : ""
+          : 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

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

+// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN:   -config="{CheckOptions: [{key: modernize-use-noexcept.AddMissingNoexcept, value: 1}]}" \
+// RUN:   -- -std=c++11 -fexceptions
+
+void undefined();
+void undefinedNoexcept() noexcept;
+
+void empty() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: this function can not throw an exception, consider adding 'noexcept'
+
+int tryCatchBody() try {
+  int Array[] = {1, 2, 3, 4};
+  throw int(42);
+  return Array[0] + Array[1] + Array[2] + Array[3];
+} catch (...) {
+  return 42;
+}
+// CHECK-MESSAGES: :[[@LINE-7]]:1: warning: this function can not throw an exception, consider adding 'noexcept'
+
+int functionCanThrow() {
+  throw int(42);
+}
+
+struct ConstructorWithNoexcept {
+  ConstructorWithNoexcept() = default;
+  int nonThrowingMember() { return 42; }
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this function can not throw an exception, consider adding 'noexcept'
+  int nonThrowingButShown() noexcept { return 42; }
+  void undefinedMethod();
+  int Member;
+};
+
+template <typename T>
+void nonThrowingTemplateUnknown();
+
+template <typename T>
+T nonThrowingTemplateKnown() {
+  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: this function can not throw an exception, consider adding 'noexcept'
+  return T{};
+}
+void instantiate() {
+  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: this function can not throw an exception, consider adding 'noexcept'
+  (void)nonThrowingTemplateKnown<int>();
+  (void)nonThrowingTemplateKnown<float>();
+  (void)nonThrowingTemplateKnown<double>();
+}

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

 // 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();
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
+// CHECK-FIXES: void f() noexcept;
 };
 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-MESSAGES: :[[@LINE-1]]:22: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-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
   ;

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

 // RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
 // RUN:   -- -std=c++11 -fexceptions
 
 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-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
 // CHECK-FIXES: void foo() noexcept;
+void footest() { foo<int>(); foo<double>(); }
 
 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);

 // 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();
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
 };
 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-MESSAGES: :[[@LINE-1]]: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();
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
 };
 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-MESSAGES: :[[@LINE-1]]: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.