added call-places of functions

Author: vbvictor

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

@@ -96,25 +96,26 @@ void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
     return;
   }
 
-  // FIXME: We should provide exact position of functions calls, not only call
-  // stack of thrown exception.
   const utils::ExceptionAnalyzer::CallStack &Stack = ThrowInfo.Stack;
-  diag(Stack.front()->getLocation(),
-       "throw stack of unhandled exception, starting from function %0",
+  diag(ThrowInfo.Loc,
+       "frame #0: unhandled exception may be thrown in function %0 here",
        DiagnosticIDs::Note)
-      << Stack.front();
-
-  size_t FrameNo = 0;
-  for (const FunctionDecl *CallNode : Stack) {
-    if (FrameNo != Stack.size() - 1) {
-      diag(CallNode->getLocation(), "frame #%0: function %1",
+      << Stack.back().first;
+
+  size_t FrameNo = 1;
+  for (auto CurrIt = ++Stack.rbegin(), PrevIt = Stack.rbegin();
+       CurrIt != Stack.rend(); ++CurrIt, ++PrevIt) {
+    const FunctionDecl *CurrFunction = CurrIt->first;
+    const FunctionDecl *PrevFunction = PrevIt->first;
+    const SourceLocation PrevLocation = PrevIt->second;
+    if (PrevLocation.isValid()) {
+      diag(PrevLocation, "frame #%0: function %1 calls function %2 here",
            DiagnosticIDs::Note)
-          << FrameNo << CallNode;
+          << FrameNo << CurrFunction << PrevFunction;
     } else {
-      diag(ThrowInfo.Loc,
-           "frame #%0: function %1 throws unhandled exception here",
-           DiagnosticIDs::Note)
-          << FrameNo << CallNode;
+      diag(CurrFunction->getLocation(),
+           "frame #%0: function %1 calls function %2", DiagnosticIDs::Note)
+          << FrameNo << CurrFunction << PrevFunction;
     }
     ++FrameNo;
   }

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

@@ -464,16 +464,15 @@ void ExceptionAnalyzer::ExceptionInfo::reevaluateBehaviour() {
   else
     Behaviour = State::Throwing;
 }
-ExceptionAnalyzer::ExceptionInfo
-ExceptionAnalyzer::throwsException(const FunctionDecl *Func,
-                                   const ExceptionInfo::Throwables &Caught,
-                                   CallStack &CallStack) {
+ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
+    const FunctionDecl *Func, const ExceptionInfo::Throwables &Caught,
+    CallStack &CallStack, SourceLocation CallLoc) {
   if (!Func || CallStack.contains(Func) ||
       (!CallStack.empty() && !canThrow(Func)))
     return ExceptionInfo::createNonThrowing();
 
   if (const Stmt *Body = Func->getBody()) {
-    CallStack.insert(Func);
+    CallStack.insert({Func, CallLoc});
     ExceptionInfo Result = throwsException(Body, Caught, CallStack);
 
     // For a constructor, we also have to check the initializers.
@@ -485,18 +484,18 @@ ExceptionAnalyzer::throwsException(const FunctionDecl *Func,
       }
     }
 
-    CallStack.remove(Func);
+    CallStack.erase(Func);
     return Result;
   }
 
   auto Result = ExceptionInfo::createUnknown();
   if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
     for (const QualType &Ex : FPT->exceptions()) {
-      CallStack.insert(Func);
+      CallStack.insert({Func, CallLoc});
       Result.registerException(
           Ex.getTypePtr(),
           {Func->getExceptionSpecSourceRange().getBegin(), CallStack});
-      CallStack.remove(Func);
+      CallStack.erase(Func);
     }
   }
   return Result;
@@ -566,12 +565,13 @@ ExceptionAnalyzer::throwsException(const Stmt *St,
     Results.merge(Uncaught);
   } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
     if (const FunctionDecl *Func = Call->getDirectCallee()) {
-      ExceptionInfo Excs = throwsException(Func, Caught, CallStack);
+      ExceptionInfo Excs =
+          throwsException(Func, Caught, CallStack, Call->getBeginLoc());
       Results.merge(Excs);
     }
   } else if (const auto *Construct = dyn_cast<CXXConstructExpr>(St)) {
-    ExceptionInfo Excs =
-        throwsException(Construct->getConstructor(), Caught, CallStack);
+    ExceptionInfo Excs = throwsException(Construct->getConstructor(), Caught,
+                                         CallStack, Construct->getBeginLoc());
     Results.merge(Excs);
   } else if (const auto *DefaultInit = dyn_cast<CXXDefaultInitExpr>(St)) {
     ExceptionInfo Excs =
@@ -590,8 +590,8 @@ ExceptionAnalyzer::throwsException(const Stmt *St,
     for (const auto &Exception : Excs.getExceptions()) {
       const Type *ExcType = Exception.getFirst();
       if (const CXXRecordDecl *ThrowableRec = ExcType->getAsCXXRecordDecl()) {
-        ExceptionInfo DestructorExcs =
-            throwsException(ThrowableRec->getDestructor(), Caught, CallStack);
+        ExceptionInfo DestructorExcs = throwsException(
+            ThrowableRec->getDestructor(), Caught, CallStack, SourceLocation{});
         Results.merge(DestructorExcs);
       }
     }
@@ -612,8 +612,8 @@ ExceptionAnalyzer::analyzeImpl(const FunctionDecl *Func) {
   const auto CacheEntry = FunctionCache.find(Func);
   if (CacheEntry == FunctionCache.end()) {
     CallStack CallStack;
-    ExceptionList =
-        throwsException(Func, ExceptionInfo::Throwables(), CallStack);
+    ExceptionList = throwsException(Func, ExceptionInfo::Throwables(),
+                                    CallStack, Func->getLocation());
 
     // Cache the result of the analysis. This is done prior to filtering
     // because it is best to keep as much information as possible.

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

@@ -29,11 +29,9 @@ class ExceptionAnalyzer {
                  ///< definition.
   };
 
-  /// We use a SetVector to preserve the order of the functions in the call
+  /// We use a MapVector to preserve the order of the functions in the call
   /// stack as well as have fast lookup.
-  using CallStack = llvm::SetVector<const FunctionDecl *,
-                                    llvm::SmallVector<const FunctionDecl *, 32>,
-                                    llvm::DenseSet<const FunctionDecl *>, 32>;
+  using CallStack = llvm::MapVector<const FunctionDecl *, SourceLocation>;
 
   /// Bundle the gathered information about an entity like a function regarding
   /// it's exception behaviour. The 'NonThrowing'-state can be considered as the
@@ -144,7 +142,7 @@ class ExceptionAnalyzer {
 private:
   ExceptionInfo throwsException(const FunctionDecl *Func,
                                 const ExceptionInfo::Throwables &Caught,
-                                CallStack &CallStack);
+                                CallStack &CallStack, SourceLocation CallLoc);
   ExceptionInfo throwsException(const Stmt *St,
                                 const ExceptionInfo::Throwables &Caught,
                                 CallStack &CallStack);