lib/Sema/SemaExceptionSpec.cpp

   1 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file provides Sema routines for C++ exception specification testing.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Sema/SemaInternal.h"
  15 #include "clang/AST/ASTMutationListener.h"
  16 #include "clang/AST/CXXInheritance.h"
  17 #include "clang/AST/Expr.h"
  18 #include "clang/AST/ExprCXX.h"
  19 #include "clang/AST/TypeLoc.h"
  20 #include "clang/Basic/Diagnostic.h"
  21 #include "clang/Basic/SourceManager.h"
  22 #include "llvm/ADT/SmallPtrSet.h"
  23 #include "llvm/ADT/SmallString.h"
  24
  25 namespace clang {
  26
  27 static const FunctionProtoType *GetUnderlyingFunction(QualType T)
  28 {
  29   if (const PointerType *PtrTy = T->getAs<PointerType>())
  30     T = PtrTy->getPointeeType();
  31   else if (const ReferenceType *RefTy = T->getAs<ReferenceType>())
  32     T = RefTy->getPointeeType();
  33   else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
  34     T = MPTy->getPointeeType();
  35   return T->getAs<FunctionProtoType>();
  36 }
  37
  38 /// HACK: libstdc++ has a bug where it shadows std::swap with a member
  39 /// swap function then tries to call std::swap unqualified from the exception
  40 /// specification of that function. This function detects whether we're in
  41 /// such a case and turns off delay-parsing of exception specifications.
  42 bool Sema::isLibstdcxxEagerExceptionSpecHack(const Declarator &D) {
  43   auto *RD = dyn_cast<CXXRecordDecl>(CurContext);
  44
  45   // All the problem cases are member functions named "swap" within class
  46   // templates declared directly within namespace std or std::__debug or
  47   // std::__profile.
  48   if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
  49       !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
  50     return false;
  51
  52   auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
  53   if (!ND)
  54     return false;
  55
  56   bool IsInStd = ND->isStdNamespace();
  57   if (!IsInStd) {
  58     // This isn't a direct member of namespace std, but it might still be
  59     // libstdc++'s std::__debug::array or std::__profile::array.
  60     IdentifierInfo *II = ND->getIdentifier();
  61     if (!II || !(II->isStr("__debug") || II->isStr("__profile")) ||
  62         !ND->isInStdNamespace())
  63       return false;
  64   }
  65
  66   // Only apply this hack within a system header.
  67   if (!Context.getSourceManager().isInSystemHeader(D.getLocStart()))
  68     return false;
  69
  70   return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
  71       .Case("array", true)
  72       .Case("pair", IsInStd)
  73       .Case("priority_queue", IsInStd)
  74       .Case("stack", IsInStd)
  75       .Case("queue", IsInStd)
  76       .Default(false);
  77 }
  78
  79 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
  80 /// exception specification. Incomplete types, or pointers to incomplete types
  81 /// other than void are not allowed.
  82 ///
  83 /// \param[in,out] T  The exception type. This will be decayed to a pointer type
  84 ///                   when the input is an array or a function type.
  85 bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) {
  86   // C++11 [except.spec]p2:
  87   //   A type cv T, "array of T", or "function returning T" denoted
  88   //   in an exception-specification is adjusted to type T, "pointer to T", or
  89   //   "pointer to function returning T", respectively.
  90   //
  91   // We also apply this rule in C++98.
  92   if (T->isArrayType())
  93     T = Context.getArrayDecayedType(T);
  94   else if (T->isFunctionType())
  95     T = Context.getPointerType(T);
  96
  97   int Kind = 0;
  98   QualType PointeeT = T;
  99   if (const PointerType *PT = T->getAs<PointerType>()) {
 100     PointeeT = PT->getPointeeType();
 101     Kind = 1;
 102
 103     // cv void* is explicitly permitted, despite being a pointer to an
 104     // incomplete type.
 105     if (PointeeT->isVoidType())
 106       return false;
 107   } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
 108     PointeeT = RT->getPointeeType();
 109     Kind = 2;
 110
 111     if (RT->isRValueReferenceType()) {
 112       // C++11 [except.spec]p2:
 113       //   A type denoted in an exception-specification shall not denote [...]
 114       //   an rvalue reference type.
 115       Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
 116         << T << Range;
 117       return true;
 118     }
 119   }
 120
 121   // C++11 [except.spec]p2:
 122   //   A type denoted in an exception-specification shall not denote an
 123   //   incomplete type other than a class currently being defined [...].
 124   //   A type denoted in an exception-specification shall not denote a
 125   //   pointer or reference to an incomplete type, other than (cv) void* or a
 126   //   pointer or reference to a class currently being defined.
 127   // In Microsoft mode, downgrade this to a warning.
 128   unsigned DiagID = diag::err_incomplete_in_exception_spec;
 129   bool ReturnValueOnError = true;
 130   if (getLangOpts().MicrosoftExt) {
 131     DiagID = diag::ext_incomplete_in_exception_spec;
 132     ReturnValueOnError = false;
 133   }
 134   if (!(PointeeT->isRecordType() &&
 135         PointeeT->getAs<RecordType>()->isBeingDefined()) &&
 136       RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
 137     return ReturnValueOnError;
 138
 139   return false;
 140 }
 141
 142 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
 143 /// to member to a function with an exception specification. This means that
 144 /// it is invalid to add another level of indirection.
 145 bool Sema::CheckDistantExceptionSpec(QualType T) {
 146   // C++17 removes this rule in favor of putting exception specifications into
 147   // the type system.
 148   if (getLangOpts().CPlusPlus1z)
 149     return false;
 150
 151   if (const PointerType *PT = T->getAs<PointerType>())
 152     T = PT->getPointeeType();
 153   else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
 154     T = PT->getPointeeType();
 155   else
 156     return false;
 157
 158   const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
 159   if (!FnT)
 160     return false;
 161
 162   return FnT->hasExceptionSpec();
 163 }
 164
 165 const FunctionProtoType *
 166 Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) {
 167   if (FPT->getExceptionSpecType() == EST_Unparsed) {
 168     Diag(Loc, diag::err_exception_spec_not_parsed);
 169     return nullptr;
 170   }
 171
 172   if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
 173     return FPT;
 174
 175   FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
 176   const FunctionProtoType *SourceFPT =
 177       SourceDecl->getType()->castAs<FunctionProtoType>();
 178
 179   // If the exception specification has already been resolved, just return it.
 180   if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType()))
 181     return SourceFPT;
 182
 183   // Compute or instantiate the exception specification now.
 184   if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
 185     EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl));
 186   else
 187     InstantiateExceptionSpec(Loc, SourceDecl);
 188
 189   const FunctionProtoType *Proto =
 190     SourceDecl->getType()->castAs<FunctionProtoType>();
 191   if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
 192     Diag(Loc, diag::err_exception_spec_not_parsed);
 193     Proto = nullptr;
 194   }
 195   return Proto;
 196 }
 197
 198 void
 199 Sema::UpdateExceptionSpec(FunctionDecl *FD,
 200                           const FunctionProtoType::ExceptionSpecInfo &ESI) {
 201   // If we've fully resolved the exception specification, notify listeners.
 202   if (!isUnresolvedExceptionSpec(ESI.Type))
 203     if (auto *Listener = getASTMutationListener())
 204       Listener->ResolvedExceptionSpec(FD);
 205
 206   for (auto *Redecl : FD->redecls())
 207     Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
 208 }
 209
 210 static bool CheckEquivalentExceptionSpecImpl(
 211     Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
 212     const FunctionProtoType *Old, SourceLocation OldLoc,
 213     const FunctionProtoType *New, SourceLocation NewLoc,
 214     bool *MissingExceptionSpecification = nullptr,
 215     bool *MissingEmptyExceptionSpecification = nullptr,
 216     bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false);
 217
 218 /// Determine whether a function has an implicitly-generated exception
 219 /// specification.
 220 static bool hasImplicitExceptionSpec(FunctionDecl *Decl) {
 221   if (!isa<CXXDestructorDecl>(Decl) &&
 222       Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
 223       Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
 224     return false;
 225
 226   // For a function that the user didn't declare:
 227   //  - if this is a destructor, its exception specification is implicit.
 228   //  - if this is 'operator delete' or 'operator delete[]', the exception
 229   //    specification is as-if an explicit exception specification was given
 230   //    (per [basic.stc.dynamic]p2).
 231   if (!Decl->getTypeSourceInfo())
 232     return isa<CXXDestructorDecl>(Decl);
 233
 234   const FunctionProtoType *Ty =
 235     Decl->getTypeSourceInfo()->getType()->getAs<FunctionProtoType>();
 236   return !Ty->hasExceptionSpec();
 237 }
 238
 239 bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
 240   // Just completely ignore this under -fno-exceptions prior to C++1z.
 241   // In C++1z onwards, the exception specification is part of the type and
 242   // we will diagnose mismatches anyway, so it's better to check for them here.
 243   if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus1z)
 244     return false;
 245
 246   OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator();
 247   bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
 248   bool MissingExceptionSpecification = false;
 249   bool MissingEmptyExceptionSpecification = false;
 250
 251   unsigned DiagID = diag::err_mismatched_exception_spec;
 252   bool ReturnValueOnError = true;
 253   if (getLangOpts().MicrosoftExt) {
 254     DiagID = diag::ext_mismatched_exception_spec;
 255     ReturnValueOnError = false;
 256   }
 257
 258   // Check the types as written: they must match before any exception
 259   // specification adjustment is applied.
 260   if (!CheckEquivalentExceptionSpecImpl(
 261         *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
 262         Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
 263         New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
 264         &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
 265         /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
 266     // C++11 [except.spec]p4 [DR1492]:
 267     //   If a declaration of a function has an implicit
 268     //   exception-specification, other declarations of the function shall
 269     //   not specify an exception-specification.
 270     if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions &&
 271         hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) {
 272       Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
 273         << hasImplicitExceptionSpec(Old);
 274       if (Old->getLocation().isValid())
 275         Diag(Old->getLocation(), diag::note_previous_declaration);
 276     }
 277     return false;
 278   }
 279
 280   // The failure was something other than an missing exception
 281   // specification; return an error, except in MS mode where this is a warning.
 282   if (!MissingExceptionSpecification)
 283     return ReturnValueOnError;
 284
 285   const FunctionProtoType *NewProto =
 286     New->getType()->castAs<FunctionProtoType>();
 287
 288   // The new function declaration is only missing an empty exception
 289   // specification "throw()". If the throw() specification came from a
 290   // function in a system header that has C linkage, just add an empty
 291   // exception specification to the "new" declaration. Note that C library
 292   // implementations are permitted to add these nothrow exception
 293   // specifications.
 294   //
 295   // Likewise if the old function is a builtin.
 296   if (MissingEmptyExceptionSpecification && NewProto &&
 297       (Old->getLocation().isInvalid() ||
 298        Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
 299        Old->getBuiltinID()) &&
 300       Old->isExternC()) {
 301     New->setType(Context.getFunctionType(
 302         NewProto->getReturnType(), NewProto->getParamTypes(),
 303         NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone)));
 304     return false;
 305   }
 306
 307   const FunctionProtoType *OldProto =
 308     Old->getType()->castAs<FunctionProtoType>();
 309
 310   FunctionProtoType::ExceptionSpecInfo ESI = OldProto->getExceptionSpecType();
 311   if (ESI.Type == EST_Dynamic) {
 312     ESI.Exceptions = OldProto->exceptions();
 313   }
 314
 315   if (ESI.Type == EST_ComputedNoexcept) {
 316     // For computed noexcept, we can't just take the expression from the old
 317     // prototype. It likely contains references to the old prototype's
 318     // parameters.
 319     New->setInvalidDecl();
 320   } else {
 321     // Update the type of the function with the appropriate exception
 322     // specification.
 323     New->setType(Context.getFunctionType(
 324         NewProto->getReturnType(), NewProto->getParamTypes(),
 325         NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
 326   }
 327
 328   if (getLangOpts().MicrosoftExt && ESI.Type != EST_ComputedNoexcept) {
 329     // Allow missing exception specifications in redeclarations as an extension.
 330     DiagID = diag::ext_ms_missing_exception_specification;
 331     ReturnValueOnError = false;
 332   } else if (New->isReplaceableGlobalAllocationFunction() &&
 333              ESI.Type != EST_ComputedNoexcept) {
 334     // Allow missing exception specifications in redeclarations as an extension,
 335     // when declaring a replaceable global allocation function.
 336     DiagID = diag::ext_missing_exception_specification;
 337     ReturnValueOnError = false;
 338   } else {
 339     DiagID = diag::err_missing_exception_specification;
 340     ReturnValueOnError = true;
 341   }
 342
 343   // Warn about the lack of exception specification.
 344   SmallString<128> ExceptionSpecString;
 345   llvm::raw_svector_ostream OS(ExceptionSpecString);
 346   switch (OldProto->getExceptionSpecType()) {
 347   case EST_DynamicNone:
 348     OS << "throw()";
 349     break;
 350
 351   case EST_Dynamic: {
 352     OS << "throw(";
 353     bool OnFirstException = true;
 354     for (const auto &E : OldProto->exceptions()) {
 355       if (OnFirstException)
 356         OnFirstException = false;
 357       else
 358         OS << ", ";
 359
 360       OS << E.getAsString(getPrintingPolicy());
 361     }
 362     OS << ")";
 363     break;
 364   }
 365
 366   case EST_BasicNoexcept:
 367     OS << "noexcept";
 368     break;
 369
 370   case EST_ComputedNoexcept:
 371     OS << "noexcept(";
 372     assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
 373     OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
 374     OS << ")";
 375     break;
 376
 377   default:
 378     llvm_unreachable("This spec type is compatible with none.");
 379   }
 380
 381   SourceLocation FixItLoc;
 382   if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
 383     TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
 384     // FIXME: Preserve enough information so that we can produce a correct fixit
 385     // location when there is a trailing return type.
 386     if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>())
 387       if (!FTLoc.getTypePtr()->hasTrailingReturn())
 388         FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
 389   }
 390
 391   if (FixItLoc.isInvalid())
 392     Diag(New->getLocation(), DiagID)
 393       << New << OS.str();
 394   else {
 395     Diag(New->getLocation(), DiagID)
 396       << New << OS.str()
 397       << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
 398   }
 399
 400   if (Old->getLocation().isValid())
 401     Diag(Old->getLocation(), diag::note_previous_declaration);
 402
 403   return ReturnValueOnError;
 404 }
 405
 406 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
 407 /// exception specifications. Exception specifications are equivalent if
 408 /// they allow exactly the same set of exception types. It does not matter how
 409 /// that is achieved. See C++ [except.spec]p2.
 410 bool Sema::CheckEquivalentExceptionSpec(
 411     const FunctionProtoType *Old, SourceLocation OldLoc,
 412     const FunctionProtoType *New, SourceLocation NewLoc) {
 413   if (!getLangOpts().CXXExceptions)
 414     return false;
 415
 416   unsigned DiagID = diag::err_mismatched_exception_spec;
 417   if (getLangOpts().MicrosoftExt)
 418     DiagID = diag::ext_mismatched_exception_spec;
 419   bool Result = CheckEquivalentExceptionSpecImpl(
 420       *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
 421       Old, OldLoc, New, NewLoc);
 422
 423   // In Microsoft mode, mismatching exception specifications just cause a warning.
 424   if (getLangOpts().MicrosoftExt)
 425     return false;
 426   return Result;
 427 }
 428
 429 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
 430 /// exception specifications. See C++ [except.spec]p3.
 431 ///
 432 /// \return \c false if the exception specifications match, \c true if there is
 433 /// a problem. If \c true is returned, either a diagnostic has already been
 434 /// produced or \c *MissingExceptionSpecification is set to \c true.
 435 static bool CheckEquivalentExceptionSpecImpl(
 436     Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
 437     const FunctionProtoType *Old, SourceLocation OldLoc,
 438     const FunctionProtoType *New, SourceLocation NewLoc,
 439     bool *MissingExceptionSpecification,
 440     bool *MissingEmptyExceptionSpecification,
 441     bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) {
 442   if (MissingExceptionSpecification)
 443     *MissingExceptionSpecification = false;
 444
 445   if (MissingEmptyExceptionSpecification)
 446     *MissingEmptyExceptionSpecification = false;
 447
 448   Old = S.ResolveExceptionSpec(NewLoc, Old);
 449   if (!Old)
 450     return false;
 451   New = S.ResolveExceptionSpec(NewLoc, New);
 452   if (!New)
 453     return false;
 454
 455   // C++0x [except.spec]p3: Two exception-specifications are compatible if:
 456   //   - both are non-throwing, regardless of their form,
 457   //   - both have the form noexcept(constant-expression) and the constant-
 458   //     expressions are equivalent,
 459   //   - both are dynamic-exception-specifications that have the same set of
 460   //     adjusted types.
 461   //
 462   // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
 463   //   of the form throw(), noexcept, or noexcept(constant-expression) where the
 464   //   constant-expression yields true.
 465   //
 466   // C++0x [except.spec]p4: If any declaration of a function has an exception-
 467   //   specifier that is not a noexcept-specification allowing all exceptions,
 468   //   all declarations [...] of that function shall have a compatible
 469   //   exception-specification.
 470   //
 471   // That last point basically means that noexcept(false) matches no spec.
 472   // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
 473
 474   ExceptionSpecificationType OldEST = Old->getExceptionSpecType();
 475   ExceptionSpecificationType NewEST = New->getExceptionSpecType();
 476
 477   assert(!isUnresolvedExceptionSpec(OldEST) &&
 478          !isUnresolvedExceptionSpec(NewEST) &&
 479          "Shouldn't see unknown exception specifications here");
 480
 481   // Shortcut the case where both have no spec.
 482   if (OldEST == EST_None && NewEST == EST_None)
 483     return false;
 484
 485   FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(S.Context);
 486   FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(S.Context);
 487   if (OldNR == FunctionProtoType::NR_BadNoexcept ||
 488       NewNR == FunctionProtoType::NR_BadNoexcept)
 489     return false;
 490
 491   // Dependent noexcept specifiers are compatible with each other, but nothing
 492   // else.
 493   // One noexcept is compatible with another if the argument is the same
 494   if (OldNR == NewNR &&
 495       OldNR != FunctionProtoType::NR_NoNoexcept &&
 496       NewNR != FunctionProtoType::NR_NoNoexcept)
 497     return false;
 498   if (OldNR != NewNR &&
 499       OldNR != FunctionProtoType::NR_NoNoexcept &&
 500       NewNR != FunctionProtoType::NR_NoNoexcept) {
 501     S.Diag(NewLoc, DiagID);
 502     if (NoteID.getDiagID() != 0 && OldLoc.isValid())
 503       S.Diag(OldLoc, NoteID);
 504     return true;
 505   }
 506
 507   // The MS extension throw(...) is compatible with itself.
 508   if (OldEST == EST_MSAny && NewEST == EST_MSAny)
 509     return false;
 510
 511   // It's also compatible with no spec.
 512   if ((OldEST == EST_None && NewEST == EST_MSAny) ||
 513       (OldEST == EST_MSAny && NewEST == EST_None))
 514     return false;
 515
 516   // It's also compatible with noexcept(false).
 517   if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw)
 518     return false;
 519   if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw)
 520     return false;
 521
 522   // As described above, noexcept(false) matches no spec only for functions.
 523   if (AllowNoexceptAllMatchWithNoSpec) {
 524     if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw)
 525       return false;
 526     if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw)
 527       return false;
 528   }
 529
 530   // Any non-throwing specifications are compatible.
 531   bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow ||
 532                         OldEST == EST_DynamicNone;
 533   bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow ||
 534                         NewEST == EST_DynamicNone;
 535   if (OldNonThrowing && NewNonThrowing)
 536     return false;
 537
 538   // As a special compatibility feature, under C++0x we accept no spec and
 539   // throw(std::bad_alloc) as equivalent for operator new and operator new[].
 540   // This is because the implicit declaration changed, but old code would break.
 541   if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) {
 542     const FunctionProtoType *WithExceptions = nullptr;
 543     if (OldEST == EST_None && NewEST == EST_Dynamic)
 544       WithExceptions = New;
 545     else if (OldEST == EST_Dynamic && NewEST == EST_None)
 546       WithExceptions = Old;
 547     if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
 548       // One has no spec, the other throw(something). If that something is
 549       // std::bad_alloc, all conditions are met.
 550       QualType Exception = *WithExceptions->exception_begin();
 551       if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
 552         IdentifierInfo* Name = ExRecord->getIdentifier();
 553         if (Name && Name->getName() == "bad_alloc") {
 554           // It's called bad_alloc, but is it in std?
 555           if (ExRecord->isInStdNamespace()) {
 556             return false;
 557           }
 558         }
 559       }
 560     }
 561   }
 562
 563   // At this point, the only remaining valid case is two matching dynamic
 564   // specifications. We return here unless both specifications are dynamic.
 565   if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) {
 566     if (MissingExceptionSpecification && Old->hasExceptionSpec() &&
 567         !New->hasExceptionSpec()) {
 568       // The old type has an exception specification of some sort, but
 569       // the new type does not.
 570       *MissingExceptionSpecification = true;
 571
 572       if (MissingEmptyExceptionSpecification && OldNonThrowing) {
 573         // The old type has a throw() or noexcept(true) exception specification
 574         // and the new type has no exception specification, and the caller asked
 575         // to handle this itself.
 576         *MissingEmptyExceptionSpecification = true;
 577       }
 578
 579       return true;
 580     }
 581
 582     S.Diag(NewLoc, DiagID);
 583     if (NoteID.getDiagID() != 0 && OldLoc.isValid())
 584       S.Diag(OldLoc, NoteID);
 585     return true;
 586   }
 587
 588   assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic &&
 589       "Exception compatibility logic error: non-dynamic spec slipped through.");
 590
 591   bool Success = true;
 592   // Both have a dynamic exception spec. Collect the first set, then compare
 593   // to the second.
 594   llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
 595   for (const auto &I : Old->exceptions())
 596     OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
 597
 598   for (const auto &I : New->exceptions()) {
 599     CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType();
 600     if (OldTypes.count(TypePtr))
 601       NewTypes.insert(TypePtr);
 602     else
 603       Success = false;
 604   }
 605
 606   Success = Success && OldTypes.size() == NewTypes.size();
 607
 608   if (Success) {
 609     return false;
 610   }
 611   S.Diag(NewLoc, DiagID);
 612   if (NoteID.getDiagID() != 0 && OldLoc.isValid())
 613     S.Diag(OldLoc, NoteID);
 614   return true;
 615 }
 616
 617 bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID,
 618                                         const PartialDiagnostic &NoteID,
 619                                         const FunctionProtoType *Old,
 620                                         SourceLocation OldLoc,
 621                                         const FunctionProtoType *New,
 622                                         SourceLocation NewLoc) {
 623   if (!getLangOpts().CXXExceptions)
 624     return false;
 625   return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc,
 626                                           New, NewLoc);
 627 }
 628
 629 /// CheckExceptionSpecSubset - Check whether the second function type's
 630 /// exception specification is a subset (or equivalent) of the first function
 631 /// type. This is used by override and pointer assignment checks.
 632 bool Sema::CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
 633                                     const PartialDiagnostic &NestedDiagID,
 634                                     const PartialDiagnostic &NoteID,
 635                                     const FunctionProtoType *Superset,
 636                                     SourceLocation SuperLoc,
 637                                     const FunctionProtoType *Subset,
 638                                     SourceLocation SubLoc) {
 639
 640   // Just auto-succeed under -fno-exceptions.
 641   if (!getLangOpts().CXXExceptions)
 642     return false;
 643
 644   // FIXME: As usual, we could be more specific in our error messages, but
 645   // that better waits until we've got types with source locations.
 646
 647   if (!SubLoc.isValid())
 648     SubLoc = SuperLoc;
 649
 650   // Resolve the exception specifications, if needed.
 651   Superset = ResolveExceptionSpec(SuperLoc, Superset);
 652   if (!Superset)
 653     return false;
 654   Subset = ResolveExceptionSpec(SubLoc, Subset);
 655   if (!Subset)
 656     return false;
 657
 658   ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
 659
 660   // If superset contains everything, we're done.
 661   if (SuperEST == EST_None || SuperEST == EST_MSAny)
 662     return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
 663                                    Subset, SubLoc);
 664
 665   // If there are dependent noexcept specs, assume everything is fine. Unlike
 666   // with the equivalency check, this is safe in this case, because we don't
 667   // want to merge declarations. Checks after instantiation will catch any
 668   // omissions we make here.
 669   // We also shortcut checking if a noexcept expression was bad.
 670
 671   FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context);
 672   if (SuperNR == FunctionProtoType::NR_BadNoexcept ||
 673       SuperNR == FunctionProtoType::NR_Dependent)
 674     return false;
 675
 676   // Another case of the superset containing everything.
 677   if (SuperNR == FunctionProtoType::NR_Throw)
 678     return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
 679                                    Subset, SubLoc);
 680
 681   ExceptionSpecificationType SubEST = Subset->getExceptionSpecType();
 682
 683   assert(!isUnresolvedExceptionSpec(SuperEST) &&
 684          !isUnresolvedExceptionSpec(SubEST) &&
 685          "Shouldn't see unknown exception specifications here");
 686
 687   // It does not. If the subset contains everything, we've failed.
 688   if (SubEST == EST_None || SubEST == EST_MSAny) {
 689     Diag(SubLoc, DiagID);
 690     if (NoteID.getDiagID() != 0)
 691       Diag(SuperLoc, NoteID);
 692     return true;
 693   }
 694
 695   FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context);
 696   if (SubNR == FunctionProtoType::NR_BadNoexcept ||
 697       SubNR == FunctionProtoType::NR_Dependent)
 698     return false;
 699
 700   // Another case of the subset containing everything.
 701   if (SubNR == FunctionProtoType::NR_Throw) {
 702     Diag(SubLoc, DiagID);
 703     if (NoteID.getDiagID() != 0)
 704       Diag(SuperLoc, NoteID);
 705     return true;
 706   }
 707
 708   // If the subset contains nothing, we're done.
 709   if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow)
 710     return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
 711                                    Subset, SubLoc);
 712
 713   // Otherwise, if the superset contains nothing, we've failed.
 714   if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) {
 715     Diag(SubLoc, DiagID);
 716     if (NoteID.getDiagID() != 0)
 717       Diag(SuperLoc, NoteID);
 718     return true;
 719   }
 720
 721   assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
 722          "Exception spec subset: non-dynamic case slipped through.");
 723
 724   // Neither contains everything or nothing. Do a proper comparison.
 725   for (const auto &SubI : Subset->exceptions()) {
 726     // Take one type from the subset.
 727     QualType CanonicalSubT = Context.getCanonicalType(SubI);
 728     // Unwrap pointers and references so that we can do checks within a class
 729     // hierarchy. Don't unwrap member pointers; they don't have hierarchy
 730     // conversions on the pointee.
 731     bool SubIsPointer = false;
 732     if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>())
 733       CanonicalSubT = RefTy->getPointeeType();
 734     if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) {
 735       CanonicalSubT = PtrTy->getPointeeType();
 736       SubIsPointer = true;
 737     }
 738     bool SubIsClass = CanonicalSubT->isRecordType();
 739     CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType();
 740
 741     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
 742                        /*DetectVirtual=*/false);
 743
 744     bool Contained = false;
 745     // Make sure it's in the superset.
 746     for (const auto &SuperI : Superset->exceptions()) {
 747       QualType CanonicalSuperT = Context.getCanonicalType(SuperI);
 748       // SubT must be SuperT or derived from it, or pointer or reference to
 749       // such types.
 750       if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>())
 751         CanonicalSuperT = RefTy->getPointeeType();
 752       if (SubIsPointer) {
 753         if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>())
 754           CanonicalSuperT = PtrTy->getPointeeType();
 755         else {
 756           continue;
 757         }
 758       }
 759       CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType();
 760       // If the types are the same, move on to the next type in the subset.
 761       if (CanonicalSubT == CanonicalSuperT) {
 762         Contained = true;
 763         break;
 764       }
 765
 766       // Otherwise we need to check the inheritance.
 767       if (!SubIsClass || !CanonicalSuperT->isRecordType())
 768         continue;
 769
 770       Paths.clear();
 771       if (!IsDerivedFrom(SubLoc, CanonicalSubT, CanonicalSuperT, Paths))
 772         continue;
 773
 774       if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT)))
 775         continue;
 776
 777       // Do this check from a context without privileges.
 778       switch (CheckBaseClassAccess(SourceLocation(),
 779                                    CanonicalSuperT, CanonicalSubT,
 780                                    Paths.front(),
 781                                    /*Diagnostic*/ 0,
 782                                    /*ForceCheck*/ true,
 783                                    /*ForceUnprivileged*/ true)) {
 784       case AR_accessible: break;
 785       case AR_inaccessible: continue;
 786       case AR_dependent:
 787         llvm_unreachable("access check dependent for unprivileged context");
 788       case AR_delayed:
 789         llvm_unreachable("access check delayed in non-declaration");
 790       }
 791
 792       Contained = true;
 793       break;
 794     }
 795     if (!Contained) {
 796       Diag(SubLoc, DiagID);
 797       if (NoteID.getDiagID() != 0)
 798         Diag(SuperLoc, NoteID);
 799       return true;
 800     }
 801   }
 802   // We've run half the gauntlet.
 803   return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
 804                                  Subset, SubLoc);
 805 }
 806
 807 static bool
 808 CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID,
 809                             const PartialDiagnostic &NoteID, QualType Target,
 810                             SourceLocation TargetLoc, QualType Source,
 811                             SourceLocation SourceLoc) {
 812   const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
 813   if (!TFunc)
 814     return false;
 815   const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
 816   if (!SFunc)
 817     return false;
 818
 819   return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
 820                                         SFunc, SourceLoc);
 821 }
 822
 823 /// CheckParamExceptionSpec - Check if the parameter and return types of the
 824 /// two functions have equivalent exception specs. This is part of the
 825 /// assignment and override compatibility check. We do not check the parameters
 826 /// of parameter function pointers recursively, as no sane programmer would
 827 /// even be able to write such a function type.
 828 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &DiagID,
 829                                    const PartialDiagnostic &NoteID,
 830                                    const FunctionProtoType *Target,
 831                                    SourceLocation TargetLoc,
 832                                    const FunctionProtoType *Source,
 833                                    SourceLocation SourceLoc) {
 834   auto RetDiag = DiagID;
 835   RetDiag << 0;
 836   if (CheckSpecForTypesEquivalent(
 837           *this, RetDiag, PDiag(),
 838           Target->getReturnType(), TargetLoc, Source->getReturnType(),
 839           SourceLoc))
 840     return true;
 841
 842   // We shouldn't even be testing this unless the arguments are otherwise
 843   // compatible.
 844   assert(Target->getNumParams() == Source->getNumParams() &&
 845          "Functions have different argument counts.");
 846   for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
 847     auto ParamDiag = DiagID;
 848     ParamDiag << 1;
 849     if (CheckSpecForTypesEquivalent(
 850             *this, ParamDiag, PDiag(),
 851             Target->getParamType(i), TargetLoc, Source->getParamType(i),
 852             SourceLoc))
 853       return true;
 854   }
 855   return false;
 856 }
 857
 858 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) {
 859   // First we check for applicability.
 860   // Target type must be a function, function pointer or function reference.
 861   const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
 862   if (!ToFunc || ToFunc->hasDependentExceptionSpec())
 863     return false;
 864
 865   // SourceType must be a function or function pointer.
 866   const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
 867   if (!FromFunc || FromFunc->hasDependentExceptionSpec())
 868     return false;
 869
 870   unsigned DiagID = diag::err_incompatible_exception_specs;
 871   unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
 872   // This is not an error in C++17 onwards, unless the noexceptness doesn't
 873   // match, but in that case we have a full-on type mismatch, not just a
 874   // type sugar mismatch.
 875   if (getLangOpts().CPlusPlus1z) {
 876     DiagID = diag::warn_incompatible_exception_specs;
 877     NestedDiagID = diag::warn_deep_exception_specs_differ;
 878   }
 879
 880   // Now we've got the correct types on both sides, check their compatibility.
 881   // This means that the source of the conversion can only throw a subset of
 882   // the exceptions of the target, and any exception specs on arguments or
 883   // return types must be equivalent.
 884   //
 885   // FIXME: If there is a nested dependent exception specification, we should
 886   // not be checking it here. This is fine:
 887   //   template<typename T> void f() {
 888   //     void (*p)(void (*) throw(T));
 889   //     void (*q)(void (*) throw(int)) = p;
 890   //   }
 891   // ... because it might be instantiated with T=int.
 892   return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(NestedDiagID), PDiag(),
 893                                   ToFunc, From->getSourceRange().getBegin(),
 894                                   FromFunc, SourceLocation()) &&
 895          !getLangOpts().CPlusPlus1z;
 896 }
 897
 898 bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
 899                                                 const CXXMethodDecl *Old) {
 900   // If the new exception specification hasn't been parsed yet, skip the check.
 901   // We'll get called again once it's been parsed.
 902   if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
 903       EST_Unparsed)
 904     return false;
 905   if (getLangOpts().CPlusPlus11 && isa<CXXDestructorDecl>(New)) {
 906     // Don't check uninstantiated template destructors at all. We can only
 907     // synthesize correct specs after the template is instantiated.
 908     if (New->getParent()->isDependentType())
 909       return false;
 910     if (New->getParent()->isBeingDefined()) {
 911       // The destructor might be updated once the definition is finished. So
 912       // remember it and check later.
 913       DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
 914       return false;
 915     }
 916   }
 917   // If the old exception specification hasn't been parsed yet, remember that
 918   // we need to perform this check when we get to the end of the outermost
 919   // lexically-surrounding class.
 920   if (Old->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
 921       EST_Unparsed) {
 922     DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
 923     return false;
 924   }
 925   unsigned DiagID = diag::err_override_exception_spec;
 926   if (getLangOpts().MicrosoftExt)
 927     DiagID = diag::ext_override_exception_spec;
 928   return CheckExceptionSpecSubset(PDiag(DiagID),
 929                                   PDiag(diag::err_deep_exception_specs_differ),
 930                                   PDiag(diag::note_overridden_virtual_function),
 931                                   Old->getType()->getAs<FunctionProtoType>(),
 932                                   Old->getLocation(),
 933                                   New->getType()->getAs<FunctionProtoType>(),
 934                                   New->getLocation());
 935 }
 936
 937 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) {
 938   CanThrowResult R = CT_Cannot;
 939   for (const Stmt *SubStmt : E->children()) {
 940     R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
 941     if (R == CT_Can)
 942       break;
 943   }
 944   return R;
 945 }
 946
 947 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
 948   // As an extension, we assume that __attribute__((nothrow)) functions don't
 949   // throw.
 950   if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
 951     return CT_Cannot;
 952
 953   QualType T;
 954
 955   // In C++1z, just look at the function type of the callee.
 956   if (S.getLangOpts().CPlusPlus1z && isa<CallExpr>(E)) {
 957     E = cast<CallExpr>(E)->getCallee();
 958     T = E->getType();
 959     if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
 960       // Sadly we don't preserve the actual type as part of the "bound member"
 961       // placeholder, so we need to reconstruct it.
 962       E = E->IgnoreParenImpCasts();
 963
 964       // Could be a call to a pointer-to-member or a plain member access.
 965       if (auto *Op = dyn_cast<BinaryOperator>(E)) {
 966         assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
 967         T = Op->getRHS()->getType()
 968               ->castAs<MemberPointerType>()->getPointeeType();
 969       } else {
 970         T = cast<MemberExpr>(E)->getMemberDecl()->getType();
 971       }
 972     }
 973   } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
 974     T = VD->getType();
 975   else
 976     // If we have no clue what we're calling, assume the worst.
 977     return CT_Can;
 978
 979   const FunctionProtoType *FT;
 980   if ((FT = T->getAs<FunctionProtoType>())) {
 981   } else if (const PointerType *PT = T->getAs<PointerType>())
 982     FT = PT->getPointeeType()->getAs<FunctionProtoType>();
 983   else if (const ReferenceType *RT = T->getAs<ReferenceType>())
 984     FT = RT->getPointeeType()->getAs<FunctionProtoType>();
 985   else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
 986     FT = MT->getPointeeType()->getAs<FunctionProtoType>();
 987   else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
 988     FT = BT->getPointeeType()->getAs<FunctionProtoType>();
 989
 990   if (!FT)
 991     return CT_Can;
 992
 993   FT = S.ResolveExceptionSpec(E->getLocStart(), FT);
 994   if (!FT)
 995     return CT_Can;
 996
 997   return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
 998 }
 999
1000 static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1001   if (DC->isTypeDependent())
1002     return CT_Dependent;
1003
1004   if (!DC->getTypeAsWritten()->isReferenceType())
1005     return CT_Cannot;
1006
1007   if (DC->getSubExpr()->isTypeDependent())
1008     return CT_Dependent;
1009
1010   return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
1011 }
1012
1013 static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) {
1014   if (DC->isTypeOperand())
1015     return CT_Cannot;
1016
1017   Expr *Op = DC->getExprOperand();
1018   if (Op->isTypeDependent())
1019     return CT_Dependent;
1020
1021   const RecordType *RT = Op->getType()->getAs<RecordType>();
1022   if (!RT)
1023     return CT_Cannot;
1024
1025   if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1026     return CT_Cannot;
1027
1028   if (Op->Classify(S.Context).isPRValue())
1029     return CT_Cannot;
1030
1031   return CT_Can;
1032 }
1033
1034 CanThrowResult Sema::canThrow(const Expr *E) {
1035   // C++ [expr.unary.noexcept]p3:
1036   //   [Can throw] if in a potentially-evaluated context the expression would
1037   //   contain:
1038   switch (E->getStmtClass()) {
1039   case Expr::CXXThrowExprClass:
1040     //   - a potentially evaluated throw-expression
1041     return CT_Can;
1042
1043   case Expr::CXXDynamicCastExprClass: {
1044     //   - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1045     //     where T is a reference type, that requires a run-time check
1046     CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E));
1047     if (CT == CT_Can)
1048       return CT;
1049     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1050   }
1051
1052   case Expr::CXXTypeidExprClass:
1053     //   - a potentially evaluated typeid expression applied to a glvalue
1054     //     expression whose type is a polymorphic class type
1055     return canTypeidThrow(*this, cast<CXXTypeidExpr>(E));
1056
1057     //   - a potentially evaluated call to a function, member function, function
1058     //     pointer, or member function pointer that does not have a non-throwing
1059     //     exception-specification
1060   case Expr::CallExprClass:
1061   case Expr::CXXMemberCallExprClass:
1062   case Expr::CXXOperatorCallExprClass:
1063   case Expr::UserDefinedLiteralClass: {
1064     const CallExpr *CE = cast<CallExpr>(E);
1065     CanThrowResult CT;
1066     if (E->isTypeDependent())
1067       CT = CT_Dependent;
1068     else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1069       CT = CT_Cannot;
1070     else
1071       CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
1072     if (CT == CT_Can)
1073       return CT;
1074     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1075   }
1076
1077   case Expr::CXXConstructExprClass:
1078   case Expr::CXXTemporaryObjectExprClass: {
1079     CanThrowResult CT = canCalleeThrow(*this, E,
1080         cast<CXXConstructExpr>(E)->getConstructor());
1081     if (CT == CT_Can)
1082       return CT;
1083     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1084   }
1085
1086   case Expr::CXXInheritedCtorInitExprClass:
1087     return canCalleeThrow(*this, E,
1088                           cast<CXXInheritedCtorInitExpr>(E)->getConstructor());
1089
1090   case Expr::LambdaExprClass: {
1091     const LambdaExpr *Lambda = cast<LambdaExpr>(E);
1092     CanThrowResult CT = CT_Cannot;
1093     for (LambdaExpr::const_capture_init_iterator
1094              Cap = Lambda->capture_init_begin(),
1095              CapEnd = Lambda->capture_init_end();
1096          Cap != CapEnd; ++Cap)
1097       CT = mergeCanThrow(CT, canThrow(*Cap));
1098     return CT;
1099   }
1100
1101   case Expr::CXXNewExprClass: {
1102     CanThrowResult CT;
1103     if (E->isTypeDependent())
1104       CT = CT_Dependent;
1105     else
1106       CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew());
1107     if (CT == CT_Can)
1108       return CT;
1109     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1110   }
1111
1112   case Expr::CXXDeleteExprClass: {
1113     CanThrowResult CT;
1114     QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType();
1115     if (DTy.isNull() || DTy->isDependentType()) {
1116       CT = CT_Dependent;
1117     } else {
1118       CT = canCalleeThrow(*this, E,
1119                           cast<CXXDeleteExpr>(E)->getOperatorDelete());
1120       if (const RecordType *RT = DTy->getAs<RecordType>()) {
1121         const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1122         const CXXDestructorDecl *DD = RD->getDestructor();
1123         if (DD)
1124           CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD));
1125       }
1126       if (CT == CT_Can)
1127         return CT;
1128     }
1129     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1130   }
1131
1132   case Expr::CXXBindTemporaryExprClass: {
1133     // The bound temporary has to be destroyed again, which might throw.
1134     CanThrowResult CT = canCalleeThrow(*this, E,
1135       cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor());
1136     if (CT == CT_Can)
1137       return CT;
1138     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1139   }
1140
1141     // ObjC message sends are like function calls, but never have exception
1142     // specs.
1143   case Expr::ObjCMessageExprClass:
1144   case Expr::ObjCPropertyRefExprClass:
1145   case Expr::ObjCSubscriptRefExprClass:
1146     return CT_Can;
1147
1148     // All the ObjC literals that are implemented as calls are
1149     // potentially throwing unless we decide to close off that
1150     // possibility.
1151   case Expr::ObjCArrayLiteralClass:
1152   case Expr::ObjCDictionaryLiteralClass:
1153   case Expr::ObjCBoxedExprClass:
1154     return CT_Can;
1155
1156     // Many other things have subexpressions, so we have to test those.
1157     // Some are simple:
1158   case Expr::CoawaitExprClass:
1159   case Expr::ConditionalOperatorClass:
1160   case Expr::CompoundLiteralExprClass:
1161   case Expr::CoyieldExprClass:
1162   case Expr::CXXConstCastExprClass:
1163   case Expr::CXXReinterpretCastExprClass:
1164   case Expr::CXXStdInitializerListExprClass:
1165   case Expr::DesignatedInitExprClass:
1166   case Expr::DesignatedInitUpdateExprClass:
1167   case Expr::ExprWithCleanupsClass:
1168   case Expr::ExtVectorElementExprClass:
1169   case Expr::InitListExprClass:
1170   case Expr::ArrayInitLoopExprClass:
1171   case Expr::MemberExprClass:
1172   case Expr::ObjCIsaExprClass:
1173   case Expr::ObjCIvarRefExprClass:
1174   case Expr::ParenExprClass:
1175   case Expr::ParenListExprClass:
1176   case Expr::ShuffleVectorExprClass:
1177   case Expr::ConvertVectorExprClass:
1178   case Expr::VAArgExprClass:
1179     return canSubExprsThrow(*this, E);
1180
1181     // Some might be dependent for other reasons.
1182   case Expr::ArraySubscriptExprClass:
1183   case Expr::OMPArraySectionExprClass:
1184   case Expr::BinaryOperatorClass:
1185   case Expr::CompoundAssignOperatorClass:
1186   case Expr::CStyleCastExprClass:
1187   case Expr::CXXStaticCastExprClass:
1188   case Expr::CXXFunctionalCastExprClass:
1189   case Expr::ImplicitCastExprClass:
1190   case Expr::MaterializeTemporaryExprClass:
1191   case Expr::UnaryOperatorClass: {
1192     CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot;
1193     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1194   }
1195
1196     // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1197   case Expr::StmtExprClass:
1198     return CT_Can;
1199
1200   case Expr::CXXDefaultArgExprClass:
1201     return canThrow(cast<CXXDefaultArgExpr>(E)->getExpr());
1202
1203   case Expr::CXXDefaultInitExprClass:
1204     return canThrow(cast<CXXDefaultInitExpr>(E)->getExpr());
1205
1206   case Expr::ChooseExprClass:
1207     if (E->isTypeDependent() || E->isValueDependent())
1208       return CT_Dependent;
1209     return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr());
1210
1211   case Expr::GenericSelectionExprClass:
1212     if (cast<GenericSelectionExpr>(E)->isResultDependent())
1213       return CT_Dependent;
1214     return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr());
1215
1216     // Some expressions are always dependent.
1217   case Expr::CXXDependentScopeMemberExprClass:
1218   case Expr::CXXUnresolvedConstructExprClass:
1219   case Expr::DependentScopeDeclRefExprClass:
1220   case Expr::CXXFoldExprClass:
1221     return CT_Dependent;
1222
1223   case Expr::AsTypeExprClass:
1224   case Expr::BinaryConditionalOperatorClass:
1225   case Expr::BlockExprClass:
1226   case Expr::CUDAKernelCallExprClass:
1227   case Expr::DeclRefExprClass:
1228   case Expr::ObjCBridgedCastExprClass:
1229   case Expr::ObjCIndirectCopyRestoreExprClass:
1230   case Expr::ObjCProtocolExprClass:
1231   case Expr::ObjCSelectorExprClass:
1232   case Expr::ObjCAvailabilityCheckExprClass:
1233   case Expr::OffsetOfExprClass:
1234   case Expr::PackExpansionExprClass:
1235   case Expr::PseudoObjectExprClass:
1236   case Expr::SubstNonTypeTemplateParmExprClass:
1237   case Expr::SubstNonTypeTemplateParmPackExprClass:
1238   case Expr::FunctionParmPackExprClass:
1239   case Expr::UnaryExprOrTypeTraitExprClass:
1240   case Expr::UnresolvedLookupExprClass:
1241   case Expr::UnresolvedMemberExprClass:
1242   case Expr::TypoExprClass:
1243     // FIXME: Can any of the above throw?  If so, when?
1244     return CT_Cannot;
1245
1246   case Expr::AddrLabelExprClass:
1247   case Expr::ArrayTypeTraitExprClass:
1248   case Expr::AtomicExprClass:
1249   case Expr::TypeTraitExprClass:
1250   case Expr::CXXBoolLiteralExprClass:
1251   case Expr::CXXNoexceptExprClass:
1252   case Expr::CXXNullPtrLiteralExprClass:
1253   case Expr::CXXPseudoDestructorExprClass:
1254   case Expr::CXXScalarValueInitExprClass:
1255   case Expr::CXXThisExprClass:
1256   case Expr::CXXUuidofExprClass:
1257   case Expr::CharacterLiteralClass:
1258   case Expr::ExpressionTraitExprClass:
1259   case Expr::FloatingLiteralClass:
1260   case Expr::GNUNullExprClass:
1261   case Expr::ImaginaryLiteralClass:
1262   case Expr::ImplicitValueInitExprClass:
1263   case Expr::IntegerLiteralClass:
1264   case Expr::ArrayInitIndexExprClass:
1265   case Expr::NoInitExprClass:
1266   case Expr::ObjCEncodeExprClass:
1267   case Expr::ObjCStringLiteralClass:
1268   case Expr::ObjCBoolLiteralExprClass:
1269   case Expr::OpaqueValueExprClass:
1270   case Expr::PredefinedExprClass:
1271   case Expr::SizeOfPackExprClass:
1272   case Expr::StringLiteralClass:
1273     // These expressions can never throw.
1274     return CT_Cannot;
1275
1276   case Expr::MSPropertyRefExprClass:
1277   case Expr::MSPropertySubscriptExprClass:
1278     llvm_unreachable("Invalid class for expression");
1279
1280 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:
1281 #define STMT_RANGE(Base, First, Last)
1282 #define LAST_STMT_RANGE(BASE, FIRST, LAST)
1283 #define EXPR(CLASS, PARENT)
1284 #define ABSTRACT_STMT(STMT)
1285 #include "clang/AST/StmtNodes.inc"
1286   case Expr::NoStmtClass:
1287     llvm_unreachable("Invalid class for expression");
1288   }
1289   llvm_unreachable("Bogus StmtClass");
1290 }
1291
1292 } // end namespace clang