[clang-tidy] Multiple fixes to bugprone-exception-escape

[PiotrZSL]

Summary

• Added support for C++17 or later in tests and added new tests
• Pointers to member functions are now handled correctly in C++20
• Move constructors and operators that are explicitly declared with noexcept(false) or throw(XYZ) are now allowed
• It is now assumed that called noexcept functions won't throw exceptions
• Warnings will now only be printed for function definitions, not declarations
• The throw exception types are now printed as a note
  
  Fixes:
  • https://github.com/llvm/llvm-project/issues/40583
  • https://github.com/llvm/llvm-project/issues/43667
  • https://github.com/llvm/llvm-project/issues/46282
  • https://github.com/llvm/llvm-project/issues/49151
  • https://github.com/llvm/llvm-project/issues/51596
  • https://github.com/llvm/llvm-project/issues/54668
  • https://github.com/llvm/llvm-project/issues/54956
  • https://github.com/llvm/llvm-project/issues/55143
  • https://github.com/llvm/llvm-project/issues/56411

[Eugene.Zelenko]

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

491–495

Please don't use auto unless type is explicitly stated in same statement or iterator.

514–517

Ditto.

clang-tools-extra/docs/ReleaseNotes.rst

308

Please keep alphabetical order (by check name) in this section.

[PiotrZSL]

Review fixes

[PiotrZSL]

Update documentation

[PiotrZSL]

This change obsoletes D115118 and D134588.

[PiotrZSL]

Ping + Rebase

[carlosgalvezp]

There's a lot of changes in this patch (at least 6 as per commit message) - please split into smaller patches fixing 1 problem at a time.

clang-tools-extra/clang-tidy/bugprone/ExceptionEscapeCheck.cpp

 
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringSet.h"
 
 using namespace clang::ast_matchers;
 
-namespace clang {
+namespace clang::tidy::bugprone {
 namespace {
 AST_MATCHER_P(FunctionDecl, isEnabled, llvm::StringSet<>,
               FunctionsThatShouldNotThrow) {
   return FunctionsThatShouldNotThrow.count(Node.getNameAsString()) > 0;
 }
+
+AST_MATCHER(FunctionDecl, isExplicitThrow) {
+  switch (Node.getExceptionSpecType()) {
+  case EST_Dynamic:
+  case EST_MSAny:
+  case EST_NoexceptFalse:
+    return Node.getExceptionSpecSourceRange().isValid();
+  default:
+    return false;
+  }
+}
+
 } // namespace
 
-namespace tidy::bugprone {
 ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get(
                                          "FunctionsThatShouldNotThrow", "")),
       RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
   llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec,
       IgnoredExceptionsVec;
   StringRef(RawFunctionsThatShouldNotThrow)

 void ExceptionEscapeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "FunctionsThatShouldNotThrow",
                 RawFunctionsThatShouldNotThrow);
   Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);
 }
 
 void ExceptionEscapeCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      functionDecl(anyOf(isNoThrow(), cxxDestructorDecl(),
+      functionDecl(
+          isDefinition(),
+          anyOf(isNoThrow(),
+                allOf(anyOf(isMain(), hasName("swap"), cxxDestructorDecl(),
                             cxxConstructorDecl(isMoveConstructor()),
-                         cxxMethodDecl(isMoveAssignmentOperator()),
-                         hasName("main"), hasName("swap"),
-                         isEnabled(FunctionsThatShouldNotThrow)))
+                            cxxMethodDecl(isMoveAssignmentOperator())),
+                      unless(isExplicitThrow())),
           .bind("thrower"),
       this);
 }
 
 void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("thrower");
 
-  if (!MatchedDecl)
+  const utils::ExceptionAnalyzer::ExceptionInfo AnalyzeResult =
+      Tracer.analyze(MatchedDecl);
+  if (!(AnalyzeResult.getBehaviour() ==
+        utils::ExceptionAnalyzer::State::Throwing))
     return;
 
-  if (Tracer.analyze(MatchedDecl).getBehaviour() ==
-      utils::ExceptionAnalyzer::State::Throwing)
-    // FIXME: We should provide more information about the exact location where
-    // the exception is thrown, maybe the full path the exception escapes
-    diag(MatchedDecl->getLocation(), "an exception may be thrown in function "
-                                     "%0 which should not throw exceptions")
-        << MatchedDecl;
+
+  for (const Type *ExceptionType : AnalyzeResult.getExceptionTypes())
+    diag(MatchedDecl->getLocation(), "may throw %0", DiagnosticIDs::Note)
+        << QualType(ExceptionType, 0U);
+
+  if (AnalyzeResult.containsUnknownElements())
+    diag(MatchedDecl->getLocation(), "may throw unknown exceptions",
+         DiagnosticIDs::Note);
 }
 
-} // namespace tidy::bugprone
-} // namespace clang
+} // namespace clang::tidy::bugprone

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

ExceptionAnalyzer::ExceptionInfo &ExceptionAnalyzer::ExceptionInfo::merge(
   ThrownExceptions.insert(Other.ThrownExceptions.begin(),
                           Other.ThrownExceptions.end());
   return *this;
 }
 
 // FIXME: This could be ported to clang later.
 namespace {
 
+bool cannotThrow(const FunctionDecl *Func) {
+  const auto *FunProto = Func->getType()->getAs<FunctionProtoType>();
+  if (!FunProto)
+    return false;
+
+  switch (FunProto->canThrow()) {
+  case CT_Cannot:
+    return true;
+  case CT_Dependent: {
+    const Expr *NoexceptExpr = FunProto->getNoexceptExpr();
+    bool Result;
+    return NoexceptExpr && !NoexceptExpr->isValueDependent() &&
+           NoexceptExpr->EvaluateAsBooleanCondition(
+               Result, Func->getASTContext(), true) &&
+           Result;
+  }
+  default:
+    return false;
+  };
+}
+
 bool isUnambiguousPublicBaseClass(const Type *DerivedType,
                                   const Type *BaseType) {
   const auto *DerivedClass =
       DerivedType->getCanonicalTypeUnqualified()->getAsCXXRecordDecl();
   const auto *BaseClass =
       BaseType->getCanonicalTypeUnqualified()->getAsCXXRecordDecl();
   if (!DerivedClass || !BaseClass)
     return false;
bool isFunctionPointerConvertible(QualType From, QualType To) {
   if (!From->isFunctionPointerType() && !From->isFunctionType() &&
       !From->isMemberFunctionPointerType())
     return false;
 
   if (!To->isFunctionPointerType() && !To->isMemberFunctionPointerType())
     return false;
 
   if (To->isFunctionPointerType()) {
+    // FIXME: Two function pointers can differ in 'noexcept', but they still
+    // should be considered to be same, now this triggers false-positive because
+    // Type* don't match
     if (From->isFunctionPointerType())
       return To->getPointeeType() == From->getPointeeType();
 
     if (From->isFunctionType())
       return To->getPointeeType() == From;
 
     return false;
   }
while (isValidP_i(From) && isValidP_i(To)) {
     if (!isSameP_i(From, To)) {
       if (LangOpts.CPlusPlus20) {
         if (From->isConstantArrayType() && !To->isIncompleteArrayType())
           return false;
 
         if (From->isIncompleteArrayType() && !To->isIncompleteArrayType())
           return false;
 
+        if (From->isMemberPointerType() || To->isMemberPointerType())
+          return false;
       } else {
         return false;
       }
     }
 
     ++I;
     std::optional<QualType> FromPointeeOrElem =
         getPointeeOrArrayElementQualType(From);
else
       Behaviour = State::NotThrowing;
   else
     Behaviour = State::Throwing;
 }
 
 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
     const FunctionDecl *Func,
     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
-  if (CallStack.count(Func))
+  if (!Func || CallStack.count(Func) ||
+      (!CallStack.empty() && cannotThrow(Func)))
     return ExceptionInfo::createNonThrowing();
 
   if (const Stmt *Body = Func->getBody()) {
     CallStack.insert(Func);
     ExceptionInfo Result =
         throwsException(Body, ExceptionInfo::Throwables(), CallStack);
 
     // For a constructor, we also have to check the initializers.
ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
     const Stmt *St, const ExceptionInfo::Throwables &Caught,
     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
   auto Results = ExceptionInfo::createNonThrowing();
   if (!St)
     return Results;
 
   if (const auto *Throw = dyn_cast<CXXThrowExpr>(St)) {
     if (const auto *ThrownExpr = Throw->getSubExpr()) {
-      const auto *ThrownType =
-          ThrownExpr->getType()->getUnqualifiedDesugaredType();
-      if (ThrownType->isReferenceType())
-        ThrownType = ThrownType->castAs<ReferenceType>()
-                         ->getPointeeType()
+      const Type *ThrownType = ThrownExpr->getType()
+                                   .getCanonicalType()
+                                   .getNonReferenceType()
                                    ->getUnqualifiedDesugaredType();
-      Results.registerException(
-          ThrownExpr->getType()->getUnqualifiedDesugaredType());
+      Results.registerException(ThrownType);
     } else
       // A rethrow of a caught exception happens which makes it possible
       // to throw all exception that are caught in the 'catch' clause of
       // the parent try-catch block.
       Results.registerExceptions(Caught);
   } else if (const auto *Try = dyn_cast<CXXTryStmt>(St)) {
     ExceptionInfo Uncaught =
         throwsException(Try->getTryBlock(), Caught, CallStack);
     for (unsigned I = 0; I < Try->getNumHandlers(); ++I) {
       const CXXCatchStmt *Catch = Try->getHandler(I);
 
       // Everything is catched through 'catch(...)'.
       if (!Catch->getExceptionDecl()) {
         ExceptionInfo Rethrown = throwsException(
             Catch->getHandlerBlock(), Uncaught.getExceptionTypes(), CallStack);
         Results.merge(Rethrown);
         Uncaught.clear();
       } else {
-        const auto *CaughtType =
-            Catch->getCaughtType()->getUnqualifiedDesugaredType();
-        if (CaughtType->isReferenceType()) {
-          CaughtType = CaughtType->castAs<ReferenceType>()
-                           ->getPointeeType()
+        const Type *CaughtType = Catch->getCaughtType()
+                                     .getCanonicalType()
+                                     .getNonReferenceType()
                                      ->getUnqualifiedDesugaredType();
-        }
-
         // If the caught exception will catch multiple previously potential
         // thrown types (because it's sensitive to inheritance) the throwing
         // situation changes. First of all filter the exception types and
         // analyze if the baseclass-exception is rethrown.
         if (Uncaught.filterByCatch(
                 CaughtType, Catch->getExceptionDecl()->getASTContext())) {
           ExceptionInfo::Throwables CaughtExceptions;
           CaughtExceptions.insert(CaughtType);

clang-tools-extra/docs/ReleaseNotes.rst

- Improved :doc:`readability-redundant-string-cstr
   arguments to ``std::print``, ``std::format`` or other functions listed in
   the ``StringParameterFunction`` check option.
 
 - Deprecated check-local options `HeaderFileExtensions`
   in :doc:`bugprone-dynamic-static-initializers
   <clang-tidy/checks/bugprone/dynamic-static-initializers>` check.
   Global options of the same name should be used instead.
 
+- Improved :doc:`bugprone-exception-escape
+  <clang-tidy/checks/bugprone/exception-escape>` by excluding explicitly
+  declared throwing functions from analysis, unless specified in the check option,
+  and respecting the ``noexcept`` specifier of called functions to handle
+  exceptions better.
+
 - Improved :doc:`bugprone-fold-init-type
   <clang-tidy/checks/bugprone/fold-init-type>` to handle iterators that do not
   define `value_type` type aliases.
 
 - Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
   in :doc:`bugprone-suspicious-include
   <clang-tidy/checks/bugprone/suspicious-include>` check.
   Global options of the same name should be used instead.
- 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.
 
 - Fixed a false positive in :doc:`cppcoreguidelines-slicing
   <clang-tidy/checks/cppcoreguidelines/slicing>` check when warning would be
   emitted in constructor for virtual base class initialization.
 
 - Improved :doc:`bugprone-use-after-move
   <clang-tidy/checks/bugprone/use-after-move>` to understand that there is a
   sequence point between designated initializers.
 
 - Fixed an issue in the :doc:`performance-noexcept-move-constructor
   <clang-tidy/checks/performance/noexcept-move-constructor>` checker that was causing
   false-positives when the move constructor or move assign operator were defaulted.
 
 - Fixed an issue in :doc:`readability-identifier-naming

clang-tools-extra/docs/clang-tidy/checks/bugprone/exception-escape.rst

 A destructor throwing an exception may result in undefined behavior, resource
 leaks or unexpected termination of the program. Throwing move constructor or
 move assignment also may result in undefined behavior or resource leak. The
 ``swap()`` operations expected to be non throwing most of the cases and they
 are always possible to implement in a non throwing way. Non throwing ``swap()``
 operations are also used to create move operations. A throwing ``main()``
 function also results in unexpected termination.
 
+Functions declared explicitly with ``noexcept(false)`` or ``throw(exception)``
+will be excluded from the analysis, as even though it is not recommended for
+functions like ``swap``, ``main``, move constructors and assignment operators,
+and destructors, it is a clear indication of the developer's intention and
+should be respected..
+
 WARNING! This check may be expensive on large source files.
 
 Options
 -------
 
 .. option:: FunctionsThatShouldNotThrow
 
    Comma separated list containing function names which should not throw. An
    example value for this parameter can be ``WinMain`` which adds function
    ``WinMain()`` in the Windows API to the list of the functions which should
    not throw. Default value is an empty string.
 
 .. option:: IgnoredExceptions
 
    Comma separated list containing type names which are not counted as thrown
    exceptions in the check. Default value is an empty string.

clang-tools-extra/test/clang-tidy/checkers/bugprone/exception-escape-throw.cpp

+// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-exception-escape %t -- -- -fexceptions
+
+void throwing_throw_nothing() throw() {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_throw_nothing' which should not throw exceptions
+  throw 1;
+}
+
+void explicit_int_thrower() throw(int);
+
+void implicit_int_thrower() {
+    throw 5;
+}
+
+void indirect_implicit() throw() {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'indirect_implicit' which should not throw exceptions
+  implicit_int_thrower();
+}
+
+void indirect_explicit() throw() {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'indirect_explicit' which should not throw exceptions
+  explicit_int_thrower();
+}
+
+struct super_throws {
+  super_throws() throw(int) { throw 42; }
+};
+
+struct sub_throws : super_throws {
+  sub_throws() throw() : super_throws() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'sub_throws' which should not throw exceptions
+};
+
+namespace PR55143 { namespace PR40583 {
+
+struct test_explicit_throw {
+    test_explicit_throw() throw(int) { throw 42; }
+    test_explicit_throw(const test_explicit_throw&) throw(int) { throw 42; }
+    test_explicit_throw(test_explicit_throw&&) throw(int) { throw 42; }
+    test_explicit_throw& operator=(const test_explicit_throw&) throw(int) { throw 42; }
+    test_explicit_throw& operator=(test_explicit_throw&&) throw(int) { throw 42; }
+    ~test_explicit_throw() throw(int) { throw 42; }
+};
+
+struct test_implicit_throw {
+    test_implicit_throw() { throw 42; }
+    test_implicit_throw(const test_implicit_throw&) { throw 42; }
+    test_implicit_throw(test_implicit_throw&&) { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'test_implicit_throw' which should not throw exceptions [bugprone-exception-escape]
+    test_implicit_throw& operator=(const test_implicit_throw&) { throw 42; }
+    test_implicit_throw& operator=(test_implicit_throw&&) { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: an exception may be thrown in function 'operator=' which should not throw exceptions [bugprone-exception-escape]
+    ~test_implicit_throw() { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function '~test_implicit_throw' which should not throw exceptions [bugprone-exception-escape]
+};
+
+}}
+
+namespace PR43667 { namespace PR51596 { // PR56411, PR54956, PR54668, PR49151
+// The following functions all incorrectly throw exceptions, *but* calling them
+// should not yield a warning because they are marked as noexcept (or similar).
+
+void test_basic_no_throw() throw() { throw 42; }
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'test_basic_no_throw' which should not throw exceptions
+void test_basic_throw() throw(int) { throw 42; }
+
+void only_calls_non_throwing() throw() {
+  test_basic_no_throw();
+}
+
+void calls_non_and_throwing() throw() {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'calls_non_and_throwing' which should not throw exceptions
+  test_basic_no_throw();
+  test_basic_throw();
+}
+
+}}
+
+namespace PR46282 {
+  void foo();
+
+  void bar() throw() {
+    foo();
+  }
+}

clang-tools-extra/test/clang-tidy/checkers/bugprone/exception-escape.cpp

-// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-exception-escape %t -- \
+// RUN: %check_clang_tidy -std=c++11-or-later %s bugprone-exception-escape %t -- \
 // RUN:     -config="{CheckOptions: [ \
 // RUN:         {key: bugprone-exception-escape.IgnoredExceptions, value: 'ignored1,ignored2'}, \
 // RUN:         {key: bugprone-exception-escape.FunctionsThatShouldNotThrow, value: 'enabled1,enabled2,enabled3'} \
 // RUN:     ]}" \
 // RUN:     -- -fexceptions
-// FIXME: Fix the checker to work in C++17 or later mode.
 
 struct throwing_destructor {
   ~throwing_destructor() {
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function '~throwing_destructor' which should not throw exceptions
     throw 1;
   }
 };
 
struct throwing_move_assignment {
   }
 };
 
 void throwing_noexcept() noexcept {
     // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_noexcept' which should not throw exceptions
   throw 1;
 }
 
-void throwing_throw_nothing() throw() {
-    // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_throw_nothing' which should not throw exceptions
-  throw 1;
-}
-
 void throw_and_catch() noexcept {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_and_catch' which should not throw exceptions
   try {
     throw 1;
   } catch(int &) {
   }
 }
 
void throw_catch_multi_ptr_4() noexcept {
   try {
     char **p = 0;
     throw p;
   } catch (volatile const char *const *) {
   }
 }
 
 // FIXME: In this case 'a' is convertible to the handler and should be caught
-// but in reality it's thrown. Note that clang doesn't report a warning for 
+// but in reality it's thrown. Note that clang doesn't report a warning for
 // this either.
 void throw_catch_multi_ptr_5() noexcept {
   try {
     double *a[2][3];
     throw a;
   } catch (double *(*)[3]) {
   }
 }
try {
     throw derived();
   } catch(alias &) {
   }
 }
 
 void throw_derived_catch_base_ptr_c() noexcept {
   try {
     derived d;
-    throw &d; 
+    throw &d;
   } catch(const base *) {
   }
 }
 
 void throw_derived_catch_base_ptr() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_ptr' which should not throw exceptions
   try {
     derived d;
     const derived *p = &d;
-    throw p; 
+    throw p;
   } catch(base *) {
   }
 }
 
 class A {};
 class B : A {};
 
 // The following alias hell is deliberately created for testing.
 using aliasedA = A;
 class C : protected aliasedA {};
 
 typedef aliasedA moreAliasedA;
 class D : public moreAliasedA {};
 
 using moreMoreAliasedA = moreAliasedA;
 using aliasedD = D;
 class E : public moreMoreAliasedA, public aliasedD {};
 
 void throw_derived_catch_base_private() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_private' which should not throw exceptions
   try {
     B b;
-    throw b; 
+    throw b;
   } catch(A) {
   }
 }
 
 void throw_derived_catch_base_private_ptr() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_private_ptr' which should not throw exceptions
   try {
     B b;
-    throw &b; 
+    throw &b;
   } catch(A *) {
   }
 }
 
 void throw_derived_catch_base_protected() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_protected' which should not throw exceptions
   try {
     C c;
-    throw c; 
+    throw c;
   } catch(A) {
   }
 }
 
 void throw_derived_catch_base_protected_ptr() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_protected_ptr' which should not throw exceptions
   try {
     C c;
-    throw &c; 
+    throw &c;
   } catch(A *) {
   }
 }
 
 void throw_derived_catch_base_ambiguous() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_ambiguous' which should not throw exceptions
   try {
     E e;
-    throw e; 
+    throw e;
   } catch(A) {
   }
 }
 
 void throw_derived_catch_base_ambiguous_ptr() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derived_catch_base_ambiguous_ptr' which should not throw exceptions
   try {
     E e;
-    throw e; 
+    throw e;
   } catch(A) {
   }
 }
 
 void throw_alias_catch_original() noexcept {
   using alias = int;
 
   try {
void throw_regular_catch_regular() noexcept {
     try {
       throw &foo;
     } catch(int (*)()) {
     }
   }
 }
 
 namespace b {
-  inline int foo() { return 0; };
+  int foo() { return 0; };
 
   void throw_inline_catch_regular() noexcept {
     try {
       throw &foo;
     } catch(int (*)()) {
     }
   }
 }
 
 namespace c {
-  inline int foo() noexcept { return 0; };
+  int foo() noexcept { return 0; };
 
   void throw_noexcept_catch_regular() noexcept {
     try {
       throw &foo;
-    } catch(int (*)()) {
+    } catch(int (*)() noexcept) {
     }
   }
 }
 
 struct baseMember {
     int *iptr;
     virtual void foo(){};
 };
void bad_catch_nested_try() noexcept {
   } catch(double &) {
   }
 }
 
 void implicit_int_thrower() {
   throw 1;
 }
 
-void explicit_int_thrower() throw(int);
+void explicit_thrower() noexcept(false) {
+  throw 1;
+}
 
 void indirect_implicit() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'indirect_implicit' which should not throw exceptions
   implicit_int_thrower();
 }
 
 void indirect_explicit() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'indirect_explicit' which should not throw exceptions
-  explicit_int_thrower();
+  explicit_thrower();
 }
 
 void indirect_catch() noexcept {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'indirect_catch' which should not throw exceptions
   try {
     implicit_int_thrower();
   } catch(int&) {
   }

 int directly_recursive(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'directly_recursive' which should not throw exceptions
   if (n == 0)
     thrower(n);
   return directly_recursive(n);
 }
 
 int indirectly_recursive(int n) noexcept;
-  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'indirectly_recursive' which should not throw exceptions
 
 int recursion_helper(int n) {
   indirectly_recursive(n);
 }
 
 int indirectly_recursive(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'indirectly_recursive' which should not throw exceptions
   if (n == 0)
     thrower(n);
   return recursion_helper(n);
 }
 
 struct super_throws {
   super_throws() noexcept(false) { throw 42; }
 };
 
 struct sub_throws : super_throws {
   sub_throws() noexcept : super_throws() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'sub_throws' which should not throw exceptions
 };
 
-struct super_throws_again {
-  super_throws_again() throw(int);
-};
-
-struct sub_throws_again : super_throws_again {
-  sub_throws_again() noexcept : super_throws_again() {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'sub_throws_again' which should not throw exceptions
-};
-
 struct init_member_throws {
   super_throws s;
 
   init_member_throws() noexcept : s() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'init_member_throws' which should not throw exceptions
 };
 
 struct implicit_init_member_throws {
struct in_class_init_throws {
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'in_class_init_throws' which should not throw exceptions
 };
 
 int main() {
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'main' which should not throw exceptions
   throw 1;
   return 0;
 }
+
+namespace PR55143 { namespace PR40583 {
+
+struct test_explicit_throw {
+    test_explicit_throw() noexcept(false) { throw 42; }
+    test_explicit_throw(const test_explicit_throw&) noexcept(false) { throw 42; }
+    test_explicit_throw(test_explicit_throw&&) noexcept(false) { throw 42; }
+    test_explicit_throw& operator=(const test_explicit_throw&) noexcept(false) { throw 42; }
+    test_explicit_throw& operator=(test_explicit_throw&&) noexcept(false) { throw 42; }
+    ~test_explicit_throw() noexcept(false) { throw 42; }
+
+    void swap(test_explicit_throw&) noexcept(false) { throw 42; }
+};
+
+
+struct test_implicit_throw {
+    test_implicit_throw() { throw 42; }
+    test_implicit_throw(const test_implicit_throw&) { throw 42; }
+    test_implicit_throw(test_implicit_throw&&) { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'test_implicit_throw' which should not throw exceptions
+    test_implicit_throw& operator=(const test_implicit_throw&) { throw 42; }
+    test_implicit_throw& operator=(test_implicit_throw&&) { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: an exception may be thrown in function 'operator=' which should not throw exceptions
+    ~test_implicit_throw() { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function '~test_implicit_throw' which should not throw exceptions
+
+    void swap(test_explicit_throw&) { throw 42; }
+    // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: an exception may be thrown in function 'swap' which should not throw exceptions
+};
+
+}}
+
+namespace PR43667 { namespace PR51596 { // PR56411, PR54956, PR54668, PR49151
+// The following functions all incorrectly throw exceptions, *but* calling them
+// should not yield a warning because they are marked as noexcept (or similar).
+
+void test_basic_noexcept() noexcept { throw 42; }
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'test_basic_noexcept' which should not throw exceptions
+void test_noexcept_true() noexcept(true) { throw 42; }
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'test_noexcept_true' which should not throw exceptions
+template <typename T>
+void test_dependent_noexcept() noexcept(T::should_throw) { throw 42; }
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'test_dependent_noexcept<PR43667::PR51596::ShouldThrow<true>>' which should not throw exceptions
+
+template <bool B>
+struct ShouldThrow {
+  static const bool should_throw = B;
+};
+
+void only_calls_non_throwing() noexcept {
+  test_basic_noexcept();
+  test_noexcept_true();
+  test_dependent_noexcept<ShouldThrow<true>>();
+}
+
+void calls_non_and_throwing() noexcept {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'calls_non_and_throwing' which should not throw exceptions
+  test_basic_noexcept();
+  test_noexcept_true();
+  test_dependent_noexcept<ShouldThrow<true>>();
+  test_dependent_noexcept<ShouldThrow<false>>();
+}
+
+}}
+
+namespace PR46282 {
+  void foo();
+
+  void bar() noexcept {
+    foo();
+  }
+}