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