[clang-tidy] Extend bugprone-exception-escape diagnostics

[PiotrZSL]

Summary

Emit additional notes with information about thrown uncaught
exceptions at a location where they thrown or re-thrown.

[isuckatcs]

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

84–86

I'm still not sure how I feel about this message though.

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

331

This continue and the other one change the behaviour of this function. Without this some additional conditions are also checked after the else if block. Shouldn't we preserve the old behaviour?

380–383

This line makes me wonder if it's worth using a map instead of a set for ThrownExceptions. You could map the type to the location. I mean technically, that happens now too, but not with the appropriate data structure.

Also I wonder what happens if a function can throw the same type from multiple locations. E.g.:

void foo(int x) {
  if(x == 0) 
    throw 1;
  
  if(x == 1)
    throw 2;
}

Here only the last location will be preserved, so maybe mapping Type to vector<SourceLocation> would be better.

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

47

What is the reason behind declaring this operator and the one below as friend?

[PiotrZSL]

Review fixes.

[PiotrZSL]

Question would be, does this can stay +- like this and we could wait with extension this until some users for example complain, that they would like it to be extended, or this need to be done now.
Main reason for this change is, that often I run into situation when there were some warning raised for some function, but after deeper investigation it were for example due to some exceptions being thrown in some boost library.
And that hard to guess were the issue were.

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

84–86

I also, my main reason was to show user that except listed exceptions, also some other exceptions may be thrown, that we do not know because they throw from an functions without implementation.
In ideal condition I should just raise this warning for a function that we called, that we do not have implementation, and we do not know what it throws.
I would say that this could be improved in future. Originally I raised all those notes against a main function, changed this recently to show were throws are called.

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

331

No, old behavior were inefficient. All push_backs push same exception into vector, that we later remove from set. So when we execute additional ifs we still going to push same execution to vector, and as a result we going to try to remove same element from set twice. That`s not needed.

380–383

We use llvm::SmallSet, but there is no llvm::SmallMap. I wanted to preserve memory optimizations, as using some map could hit performance, after all we create many of those temporary containers.
And with map I run into some issues (it didn't like const pointer as key).

As for double throw of same type. I agree, but I don't think its worth being implemented currently.
Once user remove one exception, check will show second. Many checks work like that.
This is just to provide small hint.

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

47

I just get used to do that. Usually friend enable conversion, but here we do not have constructor or derived classes, so that's not needed.
I can change this.

[isuckatcs]

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

380–383

I still feel like creating these {T, SourceLocation()} entries is bloated. In case of a map, you wouldn't need to create dummy SourceLocations.

We have DenseMap, which is documented like this:

DenseMap is a simple quadratically probed hash table. It excels at supporting small keys and values: [...] DenseMap is a great way to map pointers to pointers, or map other small types to each other.

Here you would map pointers to SourceLocations, which are basically ints, so they are smaller than pointers. I think it worths giving DenseMap a try.

Also note that the number of exceptions we store is very low, so even std::map<> wouldn't cause a significant performance loss. Also currently our SmallSet<> is set to 2 elements, which means if we store more than 2 elements, it will switch to std::set<> instead.

[PiotrZSL]

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

380–383

For SourceLocation{}, I can add constructors to ThrowInfo to hide it, but that's also not elegant solution.
Thing is that llvm::SmallSet here wont allocate memory for up to 2 elements, this mean no memory allocation and so on.
And because on every function we basically doing a copy of this container, or we create new one, then allocating memory with DenseMap could be potentially costly (allocate 64 elements).
I also run into compilation issues when using const Type* as a key for a DenseMap (yes I tried it before I choose this solution).
If we talk about std::map, well, that is a better option, as it's not allocate memory by default.
I can give it a try...

[PiotrZSL]

Use std::map

[PiotrZSL]

Ping

[PiotrZSL]

Rebase + Ping

[isuckatcs]

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

80

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

14

Is there any particular reason for taking SourceLocation by value? A const SourceLocation & would avoid an unnecessary copy.

21–22

Same question here regarding the argument type.

25–26

26

There shouldn't be any invalid location in the container. An exception is thrown by a statement, so we know where in source that happens.

324

For a moment it wasn't entirely clear for me what Fnt meant, I suggest using naming like FnType or FunctionType.

363

380–383

This introduces a side effect to this function and makes it do 2 things at the same time. Besides filtering the caught exceptions, it also collects and returns them through a reference parameter.

I don't mind the latter, but in that case I'd like to see the caught exceptions returned from the function as a part of the return statement. Also notice that if CaughtExceptions is not empty, Result is true, which makes the latter redundant. I suggest dropping the bool return type and returning the Throwables instead.

400

You are erasing something from a container on which you're iteration over. Are you sure the iterators are not invalidated, when the internal representation changes?

514

Here we rethrow something from a try block if I understand it correctly.

void foo() {
    throw 3;
}

void bar() {
    try {
        foo();
    } catch(short) {
    }
}

The best way would be to set the SourceLocation to the point, where foo() is called.
I think you would need to create a new struct called ThrowableInfo, which contains,
every information that we need to know about the Throwable e.g.: type, location, parent
context, etc. That would also be more extensible.

If there's no way to deduce this location for some reason, you can still set the location
to the try block and create messages like rethrown from try here, etc. Just don't create
invalid SourceLocations please, because besides them being incorrect, they are also
a source of bugs and crashes.

514

Also, is this branch tested? I don't see any new test case with a try block.

545

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

40

Remove this \n please, we don't have an additional new line above the ExceptionAnalyzer class either, so please keep it consistent.

[PiotrZSL]

TODO: Resolve rest of review comments.

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

14

SourceLocation is 4 bytes in size (encoded as enum). In clang is always passed by value,

21–22

Same answer, 4 bytes in size.

26

yes and no, this is an safety... and we may still not see an "throw" if we call function that explicitly declare that throw some exceptions, but we do not have definition.

400

erase returns new valid iterator
https://en.cppreference.com/w/cpp/container/map/erase

[PiotrZSL]

I do not plan to work on this check anymore, sorry for a wasted time.

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

 }
 
 void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("thrower");
 
   if (!MatchedDecl)
     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;
+  const utils::ExceptionAnalyzer::ExceptionInfo AnalyzeResult =
+      Tracer.analyze(MatchedDecl);
+  if (AnalyzeResult.getBehaviour() != utils::ExceptionAnalyzer::State::Throwing)
+    return;
+
+
+  for (auto [ThrowType, ThrowLoc] : AnalyzeResult.getExceptionTypes())
+    diag(ThrowLoc, "may throw %0 here", DiagnosticIDs::Note)
+        << QualType(ThrowType, 0U);
+
+  if (AnalyzeResult.containsUnknownElements())
+    diag(MatchedDecl->getLocation(), "may throw unknown exceptions here",
+         DiagnosticIDs::Note);
 }
 
 } // namespace tidy::bugprone
 } // namespace clang

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

 //===--- ExceptionAnalyzer.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_UTILS_EXCEPTION_ANALYZER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_EXCEPTION_ANALYZER_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringSet.h"
+#include <functional>
+#include <map>
 
 namespace clang::tidy::utils {
 
 /// This class analysis if a `FunctionDecl` can in principle throw an
 /// exception, either directly or indirectly. It can be configured to ignore
 /// custom exception types.
 class ExceptionAnalyzer {
 public:
   enum class State {
     Throwing,    ///< The function can definitely throw given an AST.
     NotThrowing, ///< This function can not throw, given an AST.
     Unknown,     ///< This can happen for extern functions without available
                  ///< definition.
   };
 
   /// Bundle the gathered information about an entity like a function regarding
   /// it's exception behaviour. The 'NonThrowing'-state can be considered as the
   /// neutral element in terms of information propagation.
   /// In the case of 'Throwing' state it is possible that 'getExceptionTypes'
   /// does not include *ALL* possible types as there is the possibility that
   /// an 'Unknown' function is called that might throw a previously unknown
   /// exception at runtime.
+
   class ExceptionInfo {
   public:
-    using Throwables = llvm::SmallSet<const Type *, 2>;
+    using Throwables = std::map<const Type *, SourceLocation>;
+
     static ExceptionInfo createUnknown() {
       return ExceptionInfo(State::Unknown);
     }
     static ExceptionInfo createNonThrowing() {
       return ExceptionInfo(State::Throwing);
     }
 
     /// By default the exception situation is unknown and must be
     /// clarified step-wise.
     ExceptionInfo() : Behaviour(State::NotThrowing), ContainsUnknown(false) {}
     ExceptionInfo(State S)
         : Behaviour(S), ContainsUnknown(S == State::Unknown) {}
 
     ExceptionInfo(const ExceptionInfo &) = default;
     ExceptionInfo &operator=(const ExceptionInfo &) = default;
     ExceptionInfo(ExceptionInfo &&) = default;
     ExceptionInfo &operator=(ExceptionInfo &&) = default;
 
     State getBehaviour() const { return Behaviour; }
 
     /// Register a single exception type as recognized potential exception to be
     /// thrown.
-    void registerException(const Type *ExceptionType);
+    void registerException(const Type *ExceptionType, const SourceLocation Loc);
 
     /// Registers a `SmallVector` of exception types as recognized potential
     /// exceptions to be thrown.
-    void registerExceptions(const Throwables &Exceptions);
+    void registerExceptions(const Throwables &Exceptions,
+                            const SourceLocation Loc);
 
     /// Updates the local state according to the other state. That means if
     /// for example a function contains multiple statements the 'ExceptionInfo'
     /// for the final function is the merged result of each statement.
     /// If one of these statements throws the whole function throws and if one
     /// part is unknown and the rest is non-throwing the result will be
     /// unknown.
     ExceptionInfo &merge(const ExceptionInfo &Other);
 
     /// This method is useful in case 'catch' clauses are analyzed as it is
     /// possible to catch multiple exception types by one 'catch' if they
     /// are a subclass of the 'catch'ed exception type.
     /// Returns 'true' if some exceptions were filtered, otherwise 'false'.
-    bool filterByCatch(const Type *BaseClass, const ASTContext &Context);
+    bool filterByCatch(const Type *BaseClass, const ASTContext &Context,
+                       Throwables &CaughtExceptions);
 
     /// Filter the set of thrown exception type against a set of ignored
     /// types that shall not be considered in the exception analysis.
     /// This includes explicit `std::bad_alloc` ignoring as separate option.
     ExceptionInfo &
     filterIgnoredExceptions(const llvm::StringSet<> &IgnoredTypes,
                             bool IgnoreBadAlloc);
 

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

 //===--- ExceptionAnalyzer.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 "ExceptionAnalyzer.h"
 
 namespace clang::tidy::utils {
 
 void ExceptionAnalyzer::ExceptionInfo::registerException(
-    const Type *ExceptionType) {
+    const Type *ExceptionType, const SourceLocation Loc) {
   assert(ExceptionType != nullptr && "Only valid types are accepted");
   Behaviour = State::Throwing;
-  ThrownExceptions.insert(ExceptionType);
+  ThrownExceptions.emplace(ExceptionType, Loc);
 }
 
 void ExceptionAnalyzer::ExceptionInfo::registerExceptions(
-    const Throwables &Exceptions) {
-  if (Exceptions.size() == 0)
+    const Throwables &Exceptions, const SourceLocation Loc) {
+  if (Exceptions.empty())
     return;
   Behaviour = State::Throwing;
-  ThrownExceptions.insert(Exceptions.begin(), Exceptions.end());
+  for (const auto [ThrowType, ThrowLoc] : Exceptions)
+    ThrownExceptions.emplace(ThrowType, ThrowLoc.isInvalid() ? Loc : ThrowLoc);
 }
 
 ExceptionAnalyzer::ExceptionInfo &ExceptionAnalyzer::ExceptionInfo::merge(
     const ExceptionAnalyzer::ExceptionInfo &Other) {
   // Only the following two cases require an update to the local
   // 'Behaviour'. If the local entity is already throwing there will be no
   // change and if the other entity is throwing the merged entity will throw
   // as well.
bool isQualificationConvertiblePointer(QualType From, QualType To,
   if (!SatisfiesCVRules(From, To))
     return false;
 
   return From.getTypePtr() == To.getTypePtr();
 }
 } // namespace
 
 bool ExceptionAnalyzer::ExceptionInfo::filterByCatch(
-    const Type *HandlerTy, const ASTContext &Context) {
-  llvm::SmallVector<const Type *, 8> TypesToDelete;
-  for (const Type *ExceptionTy : ThrownExceptions) {
+    const Type *HandlerTy, const ASTContext &Context,
+    ExceptionInfo::Throwables &CaughtExceptions) {
+
+  auto ShouldRemoveFnt = [HandlerTy, &Context](const Type *ExceptionTy) {
     CanQualType ExceptionCanTy = ExceptionTy->getCanonicalTypeUnqualified();
     CanQualType HandlerCanTy = HandlerTy->getCanonicalTypeUnqualified();
 
     // The handler is of type cv T or cv T& and E and T are the same type
     // (ignoring the top-level cv-qualifiers) ...
-    if (ExceptionCanTy == HandlerCanTy) {
-      TypesToDelete.push_back(ExceptionTy);
-    }
+    if (ExceptionCanTy == HandlerCanTy)
+      return true;
 
     // The handler is of type cv T or cv T& and T is an unambiguous public base
     // class of E ...
-    else if (isUnambiguousPublicBaseClass(ExceptionCanTy->getTypePtr(),
-                                          HandlerCanTy->getTypePtr())) {
-      TypesToDelete.push_back(ExceptionTy);
-    }
+    if (isUnambiguousPublicBaseClass(ExceptionCanTy->getTypePtr(),
+                                     HandlerCanTy->getTypePtr()))
+      return true;
 
     if (HandlerCanTy->getTypeClass() == Type::RValueReference ||
         (HandlerCanTy->getTypeClass() == Type::LValueReference &&
          !HandlerCanTy->getTypePtr()->getPointeeType().isConstQualified()))
-      continue;
+      return false;
+
     // The handler is of type cv T or const T& where T is a pointer or
     // pointer-to-member type and E is a pointer or pointer-to-member type that
     // can be converted to T by one or more of ...
     if (isPointerOrPointerToMember(HandlerCanTy->getTypePtr()) &&
         isPointerOrPointerToMember(ExceptionCanTy->getTypePtr())) {
       // A standard pointer conversion not involving conversions to pointers to
       // private or protected or ambiguous classes ...
       if (isStandardPointerConvertible(ExceptionCanTy, HandlerCanTy) &&
           isUnambiguousPublicBaseClass(
               ExceptionCanTy->getTypePtr()->getPointeeType().getTypePtr(),
-              HandlerCanTy->getTypePtr()->getPointeeType().getTypePtr())) {
-        TypesToDelete.push_back(ExceptionTy);
-      }
+              HandlerCanTy->getTypePtr()->getPointeeType().getTypePtr()))
+        return true;
       // A function pointer conversion ...
-      else if (isFunctionPointerConvertible(ExceptionCanTy, HandlerCanTy)) {
-        TypesToDelete.push_back(ExceptionTy);
-      }
+      if (isFunctionPointerConvertible(ExceptionCanTy, HandlerCanTy))
+        return true;
       // A a qualification conversion ...
-      else if (isQualificationConvertiblePointer(ExceptionCanTy, HandlerCanTy,
-                                                 Context.getLangOpts())) {
-        TypesToDelete.push_back(ExceptionTy);
-      }
+      if (isQualificationConvertiblePointer(ExceptionCanTy, HandlerCanTy,
+                                            Context.getLangOpts()))
+        return true;
+      return false;
     }
 
     // The handler is of type cv T or const T& where T is a pointer or
     // pointer-to-member type and E is std::nullptr_t.
-    else if (isPointerOrPointerToMember(HandlerCanTy->getTypePtr()) &&
-             ExceptionCanTy->isNullPtrType()) {
-      TypesToDelete.push_back(ExceptionTy);
-    }
+    return isPointerOrPointerToMember(HandlerCanTy->getTypePtr()) &&
+           ExceptionCanTy->isNullPtrType();
+  };
+
+  bool Result = false;
+  for (Throwables::iterator It = ThrownExceptions.begin();
+       It != ThrownExceptions.end();) {
+    if (!ShouldRemoveFnt(It->first)) {
+      ++It;
+      continue;
     }
 
-  for (const Type *T : TypesToDelete)
-    ThrownExceptions.erase(T);
+    CaughtExceptions.emplace(*It);
+    It = ThrownExceptions.erase(It);
+    Result = true;
+  }
 
   reevaluateBehaviour();
-  return TypesToDelete.size() > 0;
+  return Result;
 }
 
 ExceptionAnalyzer::ExceptionInfo &
 ExceptionAnalyzer::ExceptionInfo::filterIgnoredExceptions(
     const llvm::StringSet<> &IgnoredTypes, bool IgnoreBadAlloc) {
-  llvm::SmallVector<const Type *, 8> TypesToDelete;
-  // Note: Using a 'SmallSet' with 'llvm::remove_if()' is not possible.
-  // Therefore this slightly hacky implementation is required.
-  for (const Type *T : ThrownExceptions) {
-    if (const auto *TD = T->getAsTagDecl()) {
+
+  for (Throwables::iterator It = ThrownExceptions.begin();
+       It != ThrownExceptions.end();) {
+    if (const auto *TD = It->first->getAsTagDecl()) {
       if (TD->getDeclName().isIdentifier()) {
         if ((IgnoreBadAlloc &&
              (TD->getName() == "bad_alloc" && TD->isInStdNamespace())) ||
-            (IgnoredTypes.count(TD->getName()) > 0))
-          TypesToDelete.push_back(T);
+            (IgnoredTypes.count(TD->getName()) > 0)) {
+          It = ThrownExceptions.erase(It);
+          continue;
+        }
       }
     }
+    ++It;
   }
-  for (const Type *T : TypesToDelete)
-    ThrownExceptions.erase(T);
 
   reevaluateBehaviour();
   return *this;
 }
 
 void ExceptionAnalyzer::ExceptionInfo::clear() {
   Behaviour = State::NotThrowing;
   ContainsUnknown = false;
if (const Stmt *Body = Func->getBody()) {
 
     CallStack.erase(Func);
     return Result;
   }
 
   auto Result = ExceptionInfo::createUnknown();
   if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
     for (const QualType &Ex : FPT->exceptions())
-      Result.registerException(Ex.getTypePtr());
+      Result.registerException(Ex.getTypePtr(),
+                               Func->getExceptionSpecSourceRange().getBegin());
   }
   return Result;
 }
 
 /// Analyzes a single statement on it's throwing behaviour. This is in principle
 /// possible except some 'Unknown' functions are called.
 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()
                          ->getUnqualifiedDesugaredType();
       Results.registerException(
-          ThrownExpr->getType()->getUnqualifiedDesugaredType());
+          ThrownExpr->getType()->getUnqualifiedDesugaredType(),
+          Throw->getThrowLoc());
     } 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);
+      Results.registerExceptions(Caught, Throw->getThrowLoc());
   } 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()) {
for (unsigned I = 0; I < Try->getNumHandlers(); ++I) {
                            ->getPointeeType()
                            ->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);
+        if (Uncaught.filterByCatch(CaughtType,
+                                   Catch->getExceptionDecl()->getASTContext(),
+                                   CaughtExceptions)) {
+          CaughtExceptions.emplace(CaughtType, SourceLocation());
           ExceptionInfo Rethrown = throwsException(Catch->getHandlerBlock(),
                                                    CaughtExceptions, CallStack);
           Results.merge(Rethrown);
         }
       }
     }
     Results.merge(Uncaught);
   } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
for (const Stmt *Child : Coro->childrenExclBody()) {
       if (Child != Coro->getExceptionHandler()) {
         ExceptionInfo Excs = throwsException(Child, Caught, CallStack);
         Results.merge(Excs);
       }
     }
     ExceptionInfo Excs = throwsException(Coro->getBody(), Caught, CallStack);
     Results.merge(throwsException(Coro->getExceptionHandler(),
                                   Excs.getExceptionTypes(), CallStack));
-    for (const Type *Throwable : Excs.getExceptionTypes()) {
+    for (auto [Throwable, ThrowLoc] : Excs.getExceptionTypes()) {
       if (const auto ThrowableRec = Throwable->getAsCXXRecordDecl()) {
         ExceptionInfo DestructorExcs =
             throwsException(ThrowableRec->getDestructor(), Caught, CallStack);
         Results.merge(DestructorExcs);
       }
     }
   } else {
     for (const Stmt *Child : St->children()) {

clang-tools-extra/docs/ReleaseNotes.rst

- Improved :doc:`bugprone-dangling-handle
   handles behind type aliases.
 
 - 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>` to not emit warnings for
-  forward declarations of functions.
+  <clang-tidy/checks/bugprone/exception-escape>` check to not emit warnings for
+  forward declarations of functions. Emit additional diagnostic information
+  about uncaught exceptions.
 
 - Fixed :doc:`bugprone-exception-escape<clang-tidy/checks/bugprone/exception-escape>`
   for coroutines where previously a warning would be emitted with coroutines
   throwing exceptions in their bodies.
 
 - Improved :doc:`bugprone-fold-init-type
   <clang-tidy/checks/bugprone/fold-init-type>` to handle iterators that do not
   define `value_type` type aliases.

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

 }
 
 void callsRethrowerNoexcept() noexcept {
     rethrower();
 }
 
 int throwsAndCallsRethrower() noexcept {
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'throwsAndCallsRethrower' which should not throw exceptions
+// CHECK-MESSAGES: :[[@LINE+2]]:9: note: may throw 'int' here
     try {
         throw 1;
     } catch(...) {
         rethrower();
     }
 }
 
 int throwsAndCallsCallsRethrower() noexcept {
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'throwsAndCallsCallsRethrower' which should not throw exceptions
+// CHECK-MESSAGES: :[[@LINE+2]]:9: note: may throw 'int' here
     try {
         throw 1;
     } catch(...) {
         callsRethrower();
     }
 }
 
 void rethrowerNoexcept() noexcept {
     throw;
 }
+
+void throwInt() {
+  throw 5;
+}
+
+void rethrowInt() noexcept {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'rethrowInt' which should not throw exceptions [bugprone-exception-escape]
+// CHECK-MESSAGES: :[[@LINE-5]]:3: note: may throw 'int' here
+  try {
+    throwInt();
+  } catch(int) {
+    throw;
+  } catch(...) {
+  }
+}

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
+// CHECK-MESSAGES: :[[@LINE+1]]:3: note: may throw 'int' here
   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
+// CHECK-MESSAGES: :[[@LINE-5]]:3: note: may throw 'int' here
   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
+// CHECK-MESSAGES: :[[@LINE-14]]:29: note: may throw 'int' here
+// CHECK-MESSAGES: :[[@LINE-3]]:6: note: may throw unknown exceptions here
   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
+  // CHECK-MESSAGES: :[[@LINE-6]]:31: note: may throw 'int' here
 };

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:     -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
+    // CHECK-MESSAGES: :[[@LINE+1]]:5: note: may throw 'int' here
     throw 1;
   }
 };
 
 struct throwing_move_constructor {
   throwing_move_constructor(throwing_move_constructor&&) {
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'throwing_move_constructor' which should not throw exceptions
+    // CHECK-MESSAGES: :[[@LINE+1]]:5: note: may throw 'int' here
     throw 1;
   }
 };
 
 struct throwing_move_assignment {
   throwing_move_assignment& operator=(throwing_move_assignment&&) {
     // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: an exception may be thrown in function 'operator=' which should not throw exceptions
+    // CHECK-MESSAGES: :[[@LINE+1]]:5: note: may throw 'int' here
     throw 1;
   }
 };
 
 void throwing_noexcept() noexcept {
-    // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_noexcept' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: note: may throw 'int' here
   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_and_catch_some(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_and_catch_some' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'double' here
   try {
     if (n) throw 1;
     throw 1.1;
   } catch(int &) {
   }
 }
 
 void throw_and_catch_each(int n) noexcept {
try {
     if (n) throw 1;
     throw 1.1;
   } catch(...) {
   }
 }
 
 void throw_and_rethrow() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_and_rethrow' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+2]]:5: note: may throw 'int' here
   try {
     throw 1;
   } catch(int &) {
     throw;
   }
 }
 
 void throw_catch_throw() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_catch_throw' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'int' here
   try {
     throw 1;
   } catch(int &) {
     throw 2;
   }
 }
 
 void throw_catch_rethrow_the_rest(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_catch_rethrow_the_rest' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'double' here
   try {
     if (n) throw 1;
     throw 1.1;
   } catch(int &) {
   } catch(...) {
     throw;
   }
 }
void throw_catch_pointer_cv() noexcept {
   try {
     int a = 1;
     throw &a;
   } catch(const volatile int *) {}
 }
 
 void throw_catch_multi_ptr_1() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_catch_multi_ptr_1' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'char **' here
   try {
     char **p = 0;
     throw p;
   } catch (const char **) {
   }
 }
 
 void throw_catch_multi_ptr_2() noexcept {
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]) {
   }
 }
 
 
 void throw_c_catch_pointer() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_c_catch_pointer' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'const int *' here
   try {
     int a = 1;
     const int *p = &a;
     throw p;
   } catch(int *) {}
 }
 
 void throw_c_catch_pointer_v() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_c_catch_pointer_v' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'const int *' here
   try {
     int a = 1;
     const int *p = &a;
     throw p;
   } catch(volatile int *) {}
 }
 
 void throw_v_catch_pointer() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_v_catch_pointer' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'volatile int *' here
   try {
     int a = 1;
     volatile int *p = &a;
     throw p;
   } catch(int *) {}
 }
 
 void throw_v_catch_pointer_c() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_v_catch_pointer_c' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'volatile int *' here
   try {
     int a = 1;
     volatile int *p = &a;
     throw p;
   } catch(const int *) {}
 }
 
 void throw_cv_catch_pointer_c() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_cv_catch_pointer_c' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'const volatile int *' here
   try {
     int a = 1;
     const volatile int *p = &a;
     throw p;
   } catch(const int *) {}
 }
 
 void throw_cv_catch_pointer_v() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_cv_catch_pointer_v' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'const volatile int *' here
   try {
     int a = 1;
     const volatile int *p = &a;
     throw p;
   } catch(volatile int *) {}
 }
 
 class base {};
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
+  // CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'const derived *' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'B' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'B *' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'C' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'C *' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'E' here
   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
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'E *' here
   try {
     E e;
-    throw e; 
-  } catch(A) {
+    throw &e;
+  } catch(A *) {
   }
 }
 
 void throw_alias_catch_original() noexcept {
   using alias = int;
 
   try {
     alias a = 3;
     throw a;
   } catch (int) {
   }
 }
 
 void throw_alias_catch_original_warn() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_alias_catch_original_warn' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+5]]:5: note: may throw 'float' here
   using alias = float;
 
   try {
     alias a = 3;
     throw a;
   } catch (int) {
   }
 }
 
 void throw_original_catch_alias() noexcept {
   using alias = char;
 
   try {
     char **p = 0;
     throw p;
   } catch (volatile const alias *const *) {
   }
 }
 
 void throw_original_catch_alias_warn() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_original_catch_alias_warn' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+5]]:5: note: may throw 'char **' here
   using alias = int;
 
   try {
     char **p = 0;
     throw p;
   } catch (volatile const alias *const *) {
   }
 }

 };
 
 struct derivedMember : baseMember {
     void foo() override {};
 };
 
 void throw_basefn_catch_derivedfn() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_basefn_catch_derivedfn' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+2]]:5: note: may throw 'void (baseMember::*)()' here
   try {
     throw &baseMember::foo;
   } catch(void(derivedMember::*)()) {
   }
 }
 
 void throw_basefn_catch_basefn() noexcept {
   try {
     throw &baseMember::foo;
   } catch(void(baseMember::*)()) {
   }
 }
 
 void throw_basem_catch_basem_throw() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_basem_catch_basem_throw' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'int *baseMember::**' here
   try {
     auto ptr = &baseMember::iptr;
     throw &ptr;
   } catch(const int* baseMember::* const *) {
   }
 }
 
 void throw_basem_catch_basem() noexcept {
   try {
     auto ptr = &baseMember::iptr;
     throw &ptr;
   } catch(const int* const baseMember::* const *) {
   }
 }
 
 void throw_basem_catch_derivedm() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_basem_catch_derivedm' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'int *baseMember::**' here
   try {
     auto ptr = &baseMember::iptr;
     throw &ptr;
   } catch(const int* const derivedMember::* const *) {
   }
 }
 
 void throw_derivedm_catch_basem() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_derivedm_catch_basem' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'int *derivedMember::**' here
   try {
     int *derivedMember::* ptr = &derivedMember::iptr;
     throw &ptr;
   } catch(const int* const baseMember::* const *) {
   }
 }
 
 void throw_original_catch_alias_2_warn() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_original_catch_alias_2_warn' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+5]]:5: note: may throw 'char **' here
   using alias = const int *const;
 
   try {
     char **p = 0;
     throw p;
   } catch (volatile alias *) {
   }
 }
 
 void try_nested_try(int n) noexcept {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'try_nested_try' which should not throw exceptions
   try {
     try {
       if (n) throw 1;
       throw 1.1;
     } catch(int &) {
     }
   } catch(double &) {
   }
 }
 
 void bad_try_nested_try(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'bad_try_nested_try' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+2]]:12: note: may throw 'int' here
   try {
     if (n) throw 1;
     try {
       throw 1.1;
     } catch(int &) {
     }
   } catch(double &) {
   }
try {
       throw 1;
     } catch(int &) {
     }
   }
 }
 
 void bad_catch_nested_try() noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'bad_catch_nested_try' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+5]]:7: note: may throw 'double' here
   try {
     throw 1;
   } catch(int &) {
     try {
       throw 1.1;
     } catch(int &) {
     }
   } catch(double &) {
   }
 }
 
 void implicit_int_thrower() {
   throw 1;
 }
 
 void explicit_int_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
+  // CHECK-MESSAGES: :[[@LINE-9]]:3: note: may throw 'int' here
   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
+  // CHECK-MESSAGES: :[[@LINE-11]]:3: note: may throw 'int' here
   explicit_int_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&) {
   }
 }
 
 template<typename T>
 void dependent_throw() noexcept(sizeof(T)<4) {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'dependent_throw' which should not throw exceptions
   if (sizeof(T) > 4)
     throw 1;
 }
 
 void swap(int&, int&) {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'swap' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: note: may throw 'int' here
   throw 1;
 }
 
 namespace std {
 class bad_alloc {};
 }
 
 void alloc() {
   throw std::bad_alloc();
 }
 
 void allocator() noexcept {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'allocator' which should not throw exceptions
   alloc();
 }
 
 void enabled1() {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'enabled1' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: note: may throw 'int' here
   throw 1;
 }
 
 void enabled2() {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'enabled2' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE-5]]:3: note: may throw 'int' here
   enabled1();
 }
 
 void enabled3() {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'enabled3' which should not throw exceptions
   try {
     enabled1();
   } catch(...) {
try {
     throw 1;
     if (n) throw ignored2();
   } catch(int &) {
   }
 }
 
 void this_counts(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'this_counts' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: note: may throw 'int' here
   if (n) throw 1;
   throw ignored1();
 }
 
 void thrower(int n) {
   throw n;
 }
 
 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
+  // CHECK-MESSAGES: :[[@LINE-5]]:3: note: may throw 'int' here
   if (n == 0)
     thrower(n);
   return directly_recursive(n);
 }
 
 int indirectly_recursive(int n) noexcept;
 
 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
+  // CHECK-MESSAGES: :[[@LINE-19]]:3: note: may throw 'int' here
   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
+  // CHECK-MESSAGES: :[[@LINE-6]]:36: note: may throw 'int' here
 };
 
 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
+  // CHECK-MESSAGES: :[[@LINE-14]]:36: note: may throw 'int' here
 };
 
 struct implicit_init_member_throws {
   super_throws s;
 
   implicit_init_member_throws() noexcept {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'implicit_init_member_throws' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE-22]]:36: note: may throw 'int' here
 };
 
 struct init {
   explicit init(int, int) noexcept(false) { throw 42; }
 };
 
 struct in_class_init_throws {
   init i{1, 2};
 
   in_class_init_throws() noexcept {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function 'in_class_init_throws' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE-8]]:45: note: may throw 'int' here
 };
 
 int main() {
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'main' which should not throw exceptions
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: note: may throw 'int' here
   throw 1;
   return 0;
 }
+
+struct Exception1 {};
+struct Exception2 {};
+
+void throwException1Or2(bool value) noexcept {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwException1Or2' which should not throw exceptions
+// CHECK-MESSAGES: :[[@LINE+3]]:5: note: may throw 'Exception1' here
+// CHECK-MESSAGES: :[[@LINE+4]]:5: note: may throw 'Exception2' here
+  if (value)
+    throw Exception1();
+  else
+    throw Exception2();
+}
+
+void throwSomething() noexcept(false);
+
+void throwKnownAndUnknownException() noexcept {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwKnownAndUnknownException' which should not throw exceptions
+// CHECK-MESSAGES: :[[@LINE+3]]:3: note: may throw 'Exception1' here
+// CHECK-MESSAGES: :[[@LINE-3]]:6: note: may throw unknown exceptions here
+  throwSomething();
+  throw Exception1();
+}