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