contrib/llvm/tools/clang/lib/Sema/SemaExceptionSpec.cpp

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