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