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 25namespace clang { 26 27static 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. 42bool 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. 71bool 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. 125bool 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 140const FunctionProtoType * 141Sema::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 167void 168Sema::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. 181static 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 200bool 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. 345bool 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. 366bool 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. 558bool 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 726static 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. 747bool 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 772bool 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 802bool 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 840static 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 848static 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 883static 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 896static 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 917CanThrowResult 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