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

   1 //===--- ExceptionAnalyzer.cpp - clang-tidy -------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ExceptionAnalyzer.h"
  10
  11 namespace clang::tidy::utils {
  12
  13 void ExceptionAnalyzer::ExceptionInfo::registerException(
  14     const Type *ExceptionType) {
  15   assert(ExceptionType != nullptr && "Only valid types are accepted");
  16   Behaviour = State::Throwing;
  17   ThrownExceptions.insert(ExceptionType);
  18 }
  19
  20 void ExceptionAnalyzer::ExceptionInfo::registerExceptions(
  21     const Throwables &Exceptions) {
  22   if (Exceptions.size() == 0)
  23     return;
  24   Behaviour = State::Throwing;
  25   ThrownExceptions.insert(Exceptions.begin(), Exceptions.end());
  26 }
  27
  28 ExceptionAnalyzer::ExceptionInfo &ExceptionAnalyzer::ExceptionInfo::merge(
  29     const ExceptionAnalyzer::ExceptionInfo &Other) {
  30   // Only the following two cases require an update to the local
  31   // 'Behaviour'. If the local entity is already throwing there will be no
  32   // change and if the other entity is throwing the merged entity will throw
  33   // as well.
  34   // If one of both entities is 'Unknown' and the other one does not throw
  35   // the merged entity is 'Unknown' as well.
  36   if (Other.Behaviour == State::Throwing)
  37     Behaviour = State::Throwing;
  38   else if (Other.Behaviour == State::Unknown && Behaviour == State::NotThrowing)
  39     Behaviour = State::Unknown;
  40
  41   ContainsUnknown = ContainsUnknown || Other.ContainsUnknown;
  42   ThrownExceptions.insert(Other.ThrownExceptions.begin(),
  43                           Other.ThrownExceptions.end());
  44   return *this;
  45 }
  46
  47 // FIXME: This could be ported to clang later.
  48 namespace {
  49
  50 bool isUnambiguousPublicBaseClass(const Type *DerivedType,
  51                                   const Type *BaseType) {
  52   const auto *DerivedClass =
  53       DerivedType->getCanonicalTypeUnqualified()->getAsCXXRecordDecl();
  54   const auto *BaseClass =
  55       BaseType->getCanonicalTypeUnqualified()->getAsCXXRecordDecl();
  56   if (!DerivedClass || !BaseClass)
  57     return false;
  58
  59   CXXBasePaths Paths;
  60   Paths.setOrigin(DerivedClass);
  61
  62   bool IsPublicBaseClass = false;
  63   DerivedClass->lookupInBases(
  64       [&BaseClass, &IsPublicBaseClass](const CXXBaseSpecifier *BS,
  65                                        CXXBasePath &) {
  66         if (BS->getType()
  67                     ->getCanonicalTypeUnqualified()
  68                     ->getAsCXXRecordDecl() == BaseClass &&
  69             BS->getAccessSpecifier() == AS_public) {
  70           IsPublicBaseClass = true;
  71           return true;
  72         }
  73
  74         return false;
  75       },
  76       Paths);
  77
  78   return !Paths.isAmbiguous(BaseType->getCanonicalTypeUnqualified()) &&
  79          IsPublicBaseClass;
  80 }
  81
  82 inline bool isPointerOrPointerToMember(const Type *T) {
  83   return T->isPointerType() || T->isMemberPointerType();
  84 }
  85
  86 std::optional<QualType> getPointeeOrArrayElementQualType(QualType T) {
  87   if (T->isAnyPointerType() || T->isMemberPointerType())
  88     return T->getPointeeType();
  89
  90   if (T->isArrayType())
  91     return T->getAsArrayTypeUnsafe()->getElementType();
  92
  93   return std::nullopt;
  94 }
  95
  96 bool isBaseOf(const Type *DerivedType, const Type *BaseType) {
  97   const auto *DerivedClass = DerivedType->getAsCXXRecordDecl();
  98   const auto *BaseClass = BaseType->getAsCXXRecordDecl();
  99   if (!DerivedClass || !BaseClass)
 100     return false;
 101
 102   return !DerivedClass->forallBases(
 103       [BaseClass](const CXXRecordDecl *Cur) { return Cur != BaseClass; });
 104 }
 105
 106 // Check if T1 is more or Equally qualified than T2.
 107 bool moreOrEquallyQualified(QualType T1, QualType T2) {
 108   return T1.getQualifiers().isStrictSupersetOf(T2.getQualifiers()) ||
 109          T1.getQualifiers() == T2.getQualifiers();
 110 }
 111
 112 bool isStandardPointerConvertible(QualType From, QualType To) {
 113   assert((From->isPointerType() || From->isMemberPointerType()) &&
 114          (To->isPointerType() || To->isMemberPointerType()) &&
 115          "Pointer conversion should be performed on pointer types only.");
 116
 117   if (!moreOrEquallyQualified(To->getPointeeType(), From->getPointeeType()))
 118     return false;
 119
 120   // (1)
 121   // A null pointer constant can be converted to a pointer type ...
 122   // The conversion of a null pointer constant to a pointer to cv-qualified type
 123   // is a single conversion, and not the sequence of a pointer conversion
 124   // followed by a qualification conversion. A null pointer constant of integral
 125   // type can be converted to a prvalue of type std::nullptr_t
 126   if (To->isPointerType() && From->isNullPtrType())
 127     return true;
 128
 129   // (2)
 130   // A prvalue of type “pointer to cv T”, where T is an object type, can be
 131   // converted to a prvalue of type “pointer to cv void”.
 132   if (To->isVoidPointerType() && From->isObjectPointerType())
 133     return true;
 134
 135   // (3)
 136   // A prvalue of type “pointer to cv D”, where D is a complete class type, can
 137   // be converted to a prvalue of type “pointer to cv B”, where B is a base
 138   // class of D. If B is an inaccessible or ambiguous base class of D, a program
 139   // that necessitates this conversion is ill-formed.
 140   if (const auto *RD = From->getPointeeCXXRecordDecl()) {
 141     if (RD->isCompleteDefinition() &&
 142         isBaseOf(From->getPointeeType().getTypePtr(),
 143                  To->getPointeeType().getTypePtr())) {
 144       return true;
 145     }
 146   }
 147
 148   return false;
 149 }
 150
 151 bool isFunctionPointerConvertible(QualType From, QualType To) {
 152   if (!From->isFunctionPointerType() && !From->isFunctionType() &&
 153       !From->isMemberFunctionPointerType())
 154     return false;
 155
 156   if (!To->isFunctionPointerType() && !To->isMemberFunctionPointerType())
 157     return false;
 158
 159   if (To->isFunctionPointerType()) {
 160     if (From->isFunctionPointerType())
 161       return To->getPointeeType() == From->getPointeeType();
 162
 163     if (From->isFunctionType())
 164       return To->getPointeeType() == From;
 165
 166     return false;
 167   }
 168
 169   if (To->isMemberFunctionPointerType()) {
 170     if (!From->isMemberFunctionPointerType())
 171       return false;
 172
 173     const auto *FromMember = cast<MemberPointerType>(From);
 174     const auto *ToMember = cast<MemberPointerType>(To);
 175
 176     // Note: converting Derived::* to Base::* is a different kind of conversion,
 177     // called Pointer-to-member conversion.
 178     return FromMember->getClass() == ToMember->getClass() &&
 179            FromMember->getPointeeType() == ToMember->getPointeeType();
 180   }
 181
 182   return false;
 183 }
 184
 185 // Checks if From is qualification convertible to To based on the current
 186 // LangOpts. If From is any array, we perform the array to pointer conversion
 187 // first. The function only performs checks based on C++ rules, which can differ
 188 // from the C rules.
 189 //
 190 // The function should only be called in C++ mode.
 191 bool isQualificationConvertiblePointer(QualType From, QualType To,
 192                                        LangOptions LangOpts) {
 193
 194   // [N4659 7.5 (1)]
 195   // A cv-decomposition of a type T is a sequence of cv_i and P_i such that T is
 196   //    cv_0 P_0 cv_1 P_1 ... cv_n−1 P_n−1 cv_n U” for n > 0,
 197   // where each cv_i is a set of cv-qualifiers, and each P_i is “pointer to”,
 198   // “pointer to member of class C_i of type”, “array of N_i”, or
 199   // “array of unknown bound of”.
 200   //
 201   // If P_i designates an array, the cv-qualifiers cv_i+1 on the element type
 202   // are also taken as the cv-qualifiers cvi of the array.
 203   //
 204   // The n-tuple of cv-qualifiers after the first one in the longest
 205   // cv-decomposition of T, that is, cv_1, cv_2, ... , cv_n, is called the
 206   // cv-qualification signature of T.
 207
 208   auto isValidP_i = [](QualType P) {
 209     return P->isPointerType() || P->isMemberPointerType() ||
 210            P->isConstantArrayType() || P->isIncompleteArrayType();
 211   };
 212
 213   auto isSameP_i = [](QualType P1, QualType P2) {
 214     if (P1->isPointerType())
 215       return P2->isPointerType();
 216
 217     if (P1->isMemberPointerType())
 218       return P2->isMemberPointerType() &&
 219              P1->getAs<MemberPointerType>()->getClass() ==
 220                  P2->getAs<MemberPointerType>()->getClass();
 221
 222     if (P1->isConstantArrayType())
 223       return P2->isConstantArrayType() &&
 224              cast<ConstantArrayType>(P1)->getSize() ==
 225                  cast<ConstantArrayType>(P2)->getSize();
 226
 227     if (P1->isIncompleteArrayType())
 228       return P2->isIncompleteArrayType();
 229
 230     return false;
 231   };
 232
 233   // (2)
 234   // Two types From and To are similar if they have cv-decompositions with the
 235   // same n such that corresponding P_i components are the same [(added by
 236   // N4849 7.3.5) or one is “array of N_i” and the other is “array of unknown
 237   // bound of”], and the types denoted by U are the same.
 238   //
 239   // (3)
 240   // A prvalue expression of type From can be converted to type To if the
 241   // following conditions are satisfied:
 242   //  - From and To are similar
 243   //  - For every i > 0, if const is in cv_i of From then const is in cv_i of
 244   //  To, and similarly for volatile.
 245   //  - [(derived from addition by N4849 7.3.5) If P_i of From is “array of
 246   //  unknown bound of”, P_i of To is “array of unknown bound of”.]
 247   //  - If the cv_i of From and cv_i of To are different, then const is in every
 248   //  cv_k of To for 0 < k < i.
 249
 250   int I = 0;
 251   bool ConstUntilI = true;
 252   auto SatisfiesCVRules = [&I, &ConstUntilI](const QualType &From,
 253                                              const QualType &To) {
 254     if (I > 1) {
 255       if (From.getQualifiers() != To.getQualifiers() && !ConstUntilI)
 256         return false;
 257     }
 258
 259     if (I > 0) {
 260       if (From.isConstQualified() && !To.isConstQualified())
 261         return false;
 262
 263       if (From.isVolatileQualified() && !To.isVolatileQualified())
 264         return false;
 265
 266       ConstUntilI = To.isConstQualified();
 267     }
 268
 269     return true;
 270   };
 271
 272   while (isValidP_i(From) && isValidP_i(To)) {
 273     // Remove every sugar.
 274     From = From.getCanonicalType();
 275     To = To.getCanonicalType();
 276
 277     if (!SatisfiesCVRules(From, To))
 278       return false;
 279
 280     if (!isSameP_i(From, To)) {
 281       if (LangOpts.CPlusPlus20) {
 282         if (From->isConstantArrayType() && !To->isIncompleteArrayType())
 283           return false;
 284
 285         if (From->isIncompleteArrayType() && !To->isIncompleteArrayType())
 286           return false;
 287
 288       } else {
 289         return false;
 290       }
 291     }
 292
 293     ++I;
 294     std::optional<QualType> FromPointeeOrElem =
 295         getPointeeOrArrayElementQualType(From);
 296     std::optional<QualType> ToPointeeOrElem =
 297         getPointeeOrArrayElementQualType(To);
 298
 299     assert(FromPointeeOrElem &&
 300            "From pointer or array has no pointee or element!");
 301     assert(ToPointeeOrElem && "To pointer or array has no pointee or element!");
 302
 303     From = *FromPointeeOrElem;
 304     To = *ToPointeeOrElem;
 305   }
 306
 307   // In this case the length (n) of From and To are not the same.
 308   if (isValidP_i(From) || isValidP_i(To))
 309     return false;
 310
 311   // We hit U.
 312   if (!SatisfiesCVRules(From, To))
 313     return false;
 314
 315   return From.getTypePtr() == To.getTypePtr();
 316 }
 317 } // namespace
 318
 319 bool ExceptionAnalyzer::ExceptionInfo::filterByCatch(
 320     const Type *HandlerTy, const ASTContext &Context) {
 321   llvm::SmallVector<const Type *, 8> TypesToDelete;
 322   for (const Type *ExceptionTy : ThrownExceptions) {
 323     CanQualType ExceptionCanTy = ExceptionTy->getCanonicalTypeUnqualified();
 324     CanQualType HandlerCanTy = HandlerTy->getCanonicalTypeUnqualified();
 325
 326     // The handler is of type cv T or cv T& and E and T are the same type
 327     // (ignoring the top-level cv-qualifiers) ...
 328     if (ExceptionCanTy == HandlerCanTy) {
 329       TypesToDelete.push_back(ExceptionTy);
 330     }
 331
 332     // The handler is of type cv T or cv T& and T is an unambiguous public base
 333     // class of E ...
 334     else if (isUnambiguousPublicBaseClass(ExceptionCanTy->getTypePtr(),
 335                                           HandlerCanTy->getTypePtr())) {
 336       TypesToDelete.push_back(ExceptionTy);
 337     }
 338
 339     if (HandlerCanTy->getTypeClass() == Type::RValueReference ||
 340         (HandlerCanTy->getTypeClass() == Type::LValueReference &&
 341          !HandlerCanTy->getTypePtr()->getPointeeType().isConstQualified()))
 342       continue;
 343     // The handler is of type cv T or const T& where T is a pointer or
 344     // pointer-to-member type and E is a pointer or pointer-to-member type that
 345     // can be converted to T by one or more of ...
 346     if (isPointerOrPointerToMember(HandlerCanTy->getTypePtr()) &&
 347         isPointerOrPointerToMember(ExceptionCanTy->getTypePtr())) {
 348       // A standard pointer conversion not involving conversions to pointers to
 349       // private or protected or ambiguous classes ...
 350       if (isStandardPointerConvertible(ExceptionCanTy, HandlerCanTy) &&
 351           isUnambiguousPublicBaseClass(
 352               ExceptionCanTy->getTypePtr()->getPointeeType().getTypePtr(),
 353               HandlerCanTy->getTypePtr()->getPointeeType().getTypePtr())) {
 354         TypesToDelete.push_back(ExceptionTy);
 355       }
 356       // A function pointer conversion ...
 357       else if (isFunctionPointerConvertible(ExceptionCanTy, HandlerCanTy)) {
 358         TypesToDelete.push_back(ExceptionTy);
 359       }
 360       // A a qualification conversion ...
 361       else if (isQualificationConvertiblePointer(ExceptionCanTy, HandlerCanTy,
 362                                                  Context.getLangOpts())) {
 363         TypesToDelete.push_back(ExceptionTy);
 364       }
 365     }
 366
 367     // The handler is of type cv T or const T& where T is a pointer or
 368     // pointer-to-member type and E is std::nullptr_t.
 369     else if (isPointerOrPointerToMember(HandlerCanTy->getTypePtr()) &&
 370              ExceptionCanTy->isNullPtrType()) {
 371       TypesToDelete.push_back(ExceptionTy);
 372     }
 373   }
 374
 375   for (const Type *T : TypesToDelete)
 376     ThrownExceptions.erase(T);
 377
 378   reevaluateBehaviour();
 379   return TypesToDelete.size() > 0;
 380 }
 381
 382 ExceptionAnalyzer::ExceptionInfo &
 383 ExceptionAnalyzer::ExceptionInfo::filterIgnoredExceptions(
 384     const llvm::StringSet<> &IgnoredTypes, bool IgnoreBadAlloc) {
 385   llvm::SmallVector<const Type *, 8> TypesToDelete;
 386   // Note: Using a 'SmallSet' with 'llvm::remove_if()' is not possible.
 387   // Therefore this slightly hacky implementation is required.
 388   for (const Type *T : ThrownExceptions) {
 389     if (const auto *TD = T->getAsTagDecl()) {
 390       if (TD->getDeclName().isIdentifier()) {
 391         if ((IgnoreBadAlloc &&
 392              (TD->getName() == "bad_alloc" && TD->isInStdNamespace())) ||
 393             (IgnoredTypes.count(TD->getName()) > 0))
 394           TypesToDelete.push_back(T);
 395       }
 396     }
 397   }
 398   for (const Type *T : TypesToDelete)
 399     ThrownExceptions.erase(T);
 400
 401   reevaluateBehaviour();
 402   return *this;
 403 }
 404
 405 void ExceptionAnalyzer::ExceptionInfo::clear() {
 406   Behaviour = State::NotThrowing;
 407   ContainsUnknown = false;
 408   ThrownExceptions.clear();
 409 }
 410
 411 void ExceptionAnalyzer::ExceptionInfo::reevaluateBehaviour() {
 412   if (ThrownExceptions.size() == 0)
 413     if (ContainsUnknown)
 414       Behaviour = State::Unknown;
 415     else
 416       Behaviour = State::NotThrowing;
 417   else
 418     Behaviour = State::Throwing;
 419 }
 420
 421 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
 422     const FunctionDecl *Func, const ExceptionInfo::Throwables &Caught,
 423     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
 424   if (CallStack.count(Func))
 425     return ExceptionInfo::createNonThrowing();
 426
 427   if (const Stmt *Body = Func->getBody()) {
 428     CallStack.insert(Func);
 429     ExceptionInfo Result = throwsException(Body, Caught, CallStack);
 430
 431     // For a constructor, we also have to check the initializers.
 432     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Func)) {
 433       for (const CXXCtorInitializer *Init : Ctor->inits()) {
 434         ExceptionInfo Excs =
 435             throwsException(Init->getInit(), Caught, CallStack);
 436         Result.merge(Excs);
 437       }
 438     }
 439
 440     CallStack.erase(Func);
 441     return Result;
 442   }
 443
 444   auto Result = ExceptionInfo::createUnknown();
 445   if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
 446     for (const QualType &Ex : FPT->exceptions())
 447       Result.registerException(Ex.getTypePtr());
 448   }
 449   return Result;
 450 }
 451
 452 /// Analyzes a single statement on it's throwing behaviour. This is in principle
 453 /// possible except some 'Unknown' functions are called.
 454 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
 455     const Stmt *St, const ExceptionInfo::Throwables &Caught,
 456     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
 457   auto Results = ExceptionInfo::createNonThrowing();
 458   if (!St)
 459     return Results;
 460
 461   if (const auto *Throw = dyn_cast<CXXThrowExpr>(St)) {
 462     if (const auto *ThrownExpr = Throw->getSubExpr()) {
 463       const auto *ThrownType =
 464           ThrownExpr->getType()->getUnqualifiedDesugaredType();
 465       if (ThrownType->isReferenceType())
 466         ThrownType = ThrownType->castAs<ReferenceType>()
 467                          ->getPointeeType()
 468                          ->getUnqualifiedDesugaredType();
 469       Results.registerException(
 470           ThrownExpr->getType()->getUnqualifiedDesugaredType());
 471     } else
 472       // A rethrow of a caught exception happens which makes it possible
 473       // to throw all exception that are caught in the 'catch' clause of
 474       // the parent try-catch block.
 475       Results.registerExceptions(Caught);
 476   } else if (const auto *Try = dyn_cast<CXXTryStmt>(St)) {
 477     ExceptionInfo Uncaught =
 478         throwsException(Try->getTryBlock(), Caught, CallStack);
 479     for (unsigned I = 0; I < Try->getNumHandlers(); ++I) {
 480       const CXXCatchStmt *Catch = Try->getHandler(I);
 481
 482       // Everything is catched through 'catch(...)'.
 483       if (!Catch->getExceptionDecl()) {
 484         ExceptionInfo Rethrown = throwsException(
 485             Catch->getHandlerBlock(), Uncaught.getExceptionTypes(), CallStack);
 486         Results.merge(Rethrown);
 487         Uncaught.clear();
 488       } else {
 489         const auto *CaughtType =
 490             Catch->getCaughtType()->getUnqualifiedDesugaredType();
 491         if (CaughtType->isReferenceType()) {
 492           CaughtType = CaughtType->castAs<ReferenceType>()
 493                            ->getPointeeType()
 494                            ->getUnqualifiedDesugaredType();
 495         }
 496
 497         // If the caught exception will catch multiple previously potential
 498         // thrown types (because it's sensitive to inheritance) the throwing
 499         // situation changes. First of all filter the exception types and
 500         // analyze if the baseclass-exception is rethrown.
 501         if (Uncaught.filterByCatch(
 502                 CaughtType, Catch->getExceptionDecl()->getASTContext())) {
 503           ExceptionInfo::Throwables CaughtExceptions;
 504           CaughtExceptions.insert(CaughtType);
 505           ExceptionInfo Rethrown = throwsException(Catch->getHandlerBlock(),
 506                                                    CaughtExceptions, CallStack);
 507           Results.merge(Rethrown);
 508         }
 509       }
 510     }
 511     Results.merge(Uncaught);
 512   } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
 513     if (const FunctionDecl *Func = Call->getDirectCallee()) {
 514       ExceptionInfo Excs = throwsException(Func, Caught, CallStack);
 515       Results.merge(Excs);
 516     }
 517   } else if (const auto *Construct = dyn_cast<CXXConstructExpr>(St)) {
 518     ExceptionInfo Excs =
 519         throwsException(Construct->getConstructor(), Caught, CallStack);
 520     Results.merge(Excs);
 521   } else if (const auto *DefaultInit = dyn_cast<CXXDefaultInitExpr>(St)) {
 522     ExceptionInfo Excs =
 523         throwsException(DefaultInit->getExpr(), Caught, CallStack);
 524     Results.merge(Excs);
 525   } else if (const auto *Coro = dyn_cast<CoroutineBodyStmt>(St)) {
 526     for (const Stmt *Child : Coro->childrenExclBody()) {
 527       if (Child != Coro->getExceptionHandler()) {
 528         ExceptionInfo Excs = throwsException(Child, Caught, CallStack);
 529         Results.merge(Excs);
 530       }
 531     }
 532     ExceptionInfo Excs = throwsException(Coro->getBody(), Caught, CallStack);
 533     Results.merge(throwsException(Coro->getExceptionHandler(),
 534                                   Excs.getExceptionTypes(), CallStack));
 535     for (const Type *Throwable : Excs.getExceptionTypes()) {
 536       if (const auto ThrowableRec = Throwable->getAsCXXRecordDecl()) {
 537         ExceptionInfo DestructorExcs =
 538             throwsException(ThrowableRec->getDestructor(), Caught, CallStack);
 539         Results.merge(DestructorExcs);
 540       }
 541     }
 542   } else {
 543     for (const Stmt *Child : St->children()) {
 544       ExceptionInfo Excs = throwsException(Child, Caught, CallStack);
 545       Results.merge(Excs);
 546     }
 547   }
 548   return Results;
 549 }
 550
 551 ExceptionAnalyzer::ExceptionInfo
 552 ExceptionAnalyzer::analyzeImpl(const FunctionDecl *Func) {
 553   ExceptionInfo ExceptionList;
 554
 555   // Check if the function has already been analyzed and reuse that result.
 556   const auto CacheEntry = FunctionCache.find(Func);
 557   if (CacheEntry == FunctionCache.end()) {
 558     llvm::SmallSet<const FunctionDecl *, 32> CallStack;
 559     ExceptionList =
 560         throwsException(Func, ExceptionInfo::Throwables(), CallStack);
 561
 562     // Cache the result of the analysis. This is done prior to filtering
 563     // because it is best to keep as much information as possible.
 564     // The results here might be relevant to different analysis passes
 565     // with different needs as well.
 566     FunctionCache.try_emplace(Func, ExceptionList);
 567   } else
 568     ExceptionList = CacheEntry->getSecond();
 569
 570   return ExceptionList;
 571 }
 572
 573 ExceptionAnalyzer::ExceptionInfo
 574 ExceptionAnalyzer::analyzeImpl(const Stmt *Stmt) {
 575   llvm::SmallSet<const FunctionDecl *, 32> CallStack;
 576   return throwsException(Stmt, ExceptionInfo::Throwables(), CallStack);
 577 }
 578
 579 template <typename T>
 580 ExceptionAnalyzer::ExceptionInfo
 581 ExceptionAnalyzer::analyzeDispatch(const T *Node) {
 582   ExceptionInfo ExceptionList = analyzeImpl(Node);
 583
 584   if (ExceptionList.getBehaviour() == State::NotThrowing ||
 585       ExceptionList.getBehaviour() == State::Unknown)
 586     return ExceptionList;
 587
 588   // Remove all ignored exceptions from the list of exceptions that can be
 589   // thrown.
 590   ExceptionList.filterIgnoredExceptions(IgnoredExceptions, IgnoreBadAlloc);
 591
 592   return ExceptionList;
 593 }
 594
 595 ExceptionAnalyzer::ExceptionInfo
 596 ExceptionAnalyzer::analyze(const FunctionDecl *Func) {
 597   return analyzeDispatch(Func);
 598 }
 599
 600 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::analyze(const Stmt *Stmt) {
 601   return analyzeDispatch(Stmt);
 602 }
 603
 604 } // namespace clang::tidy::utils