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
  24 namespace clang {
  25
  26 static const FunctionProtoType *GetUnderlyingFunction(QualType T)
  27 {
  28   if (const PointerType *PtrTy = T->getAs<PointerType>())
  29     T = PtrTy->getPointeeType();
  30   else if (const ReferenceType *RefTy = T->getAs<ReferenceType>())
  31     T = RefTy->getPointeeType();
  32   else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
  33     T = MPTy->getPointeeType();
  34   return T->getAs<FunctionProtoType>();
  35 }
  36
  37 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
  38 /// exception specification. Incomplete types, or pointers to incomplete types
  39 /// other than void are not allowed.
  40 bool Sema::CheckSpecifiedExceptionType(QualType T, const SourceRange &Range) {
  41
  42   // This check (and the similar one below) deals with issue 437, that changes
  43   // C++ 9.2p2 this way:
  44   // Within the class member-specification, the class is regarded as complete
  45   // within function bodies, default arguments, exception-specifications, and
  46   // constructor ctor-initializers (including such things in nested classes).
  47   if (T->isRecordType() && T->getAs<RecordType>()->isBeingDefined())
  48     return false;
  49
  50   // C++ 15.4p2: A type denoted in an exception-specification shall not denote
  51   //   an incomplete type.
  52   if (RequireCompleteType(Range.getBegin(), T,
  53       PDiag(diag::err_incomplete_in_exception_spec) << /*direct*/0 << Range))
  54     return true;
  55
  56   // C++ 15.4p2: A type denoted in an exception-specification shall not denote
  57   //   an incomplete type a pointer or reference to an incomplete type, other
  58   //   than (cv) void*.
  59   int kind;
  60   if (const PointerType* IT = T->getAs<PointerType>()) {
  61     T = IT->getPointeeType();
  62     kind = 1;
  63   } else if (const ReferenceType* IT = T->getAs<ReferenceType>()) {
  64     T = IT->getPointeeType();
  65     kind = 2;
  66   } else
  67     return false;
  68
  69   // Again as before
  70   if (T->isRecordType() && T->getAs<RecordType>()->isBeingDefined())
  71     return false;
  72
  73   if (!T->isVoidType() && RequireCompleteType(Range.getBegin(), T,
  74       PDiag(diag::err_incomplete_in_exception_spec) << kind << Range))
  75     return true;
  76
  77   return false;
  78 }
  79
  80 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
  81 /// to member to a function with an exception specification. This means that
  82 /// it is invalid to add another level of indirection.
  83 bool Sema::CheckDistantExceptionSpec(QualType T) {
  84   if (const PointerType *PT = T->getAs<PointerType>())
  85     T = PT->getPointeeType();
  86   else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
  87     T = PT->getPointeeType();
  88   else
  89     return false;
  90
  91   const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
  92   if (!FnT)
  93     return false;
  94
  95   return FnT->hasExceptionSpec();
  96 }
  97
  98 bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
  99   OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator();
 100   bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
 101   bool MissingExceptionSpecification = false;
 102   bool MissingEmptyExceptionSpecification = false;
 103   unsigned DiagID = diag::err_mismatched_exception_spec;
 104   if (getLangOptions().MicrosoftExt)
 105     DiagID = diag::warn_mismatched_exception_spec;
 106
 107   if (!CheckEquivalentExceptionSpec(PDiag(DiagID),
 108                                     PDiag(diag::note_previous_declaration),
 109                                     Old->getType()->getAs<FunctionProtoType>(),
 110                                     Old->getLocation(),
 111                                     New->getType()->getAs<FunctionProtoType>(),
 112                                     New->getLocation(),
 113                                     &MissingExceptionSpecification,
 114                                     &MissingEmptyExceptionSpecification,
 115                                     /*AllowNoexceptAllMatchWithNoSpec=*/true,
 116                                     IsOperatorNew))
 117     return false;
 118
 119   // The failure was something other than an empty exception
 120   // specification; return an error.
 121   if (!MissingExceptionSpecification && !MissingEmptyExceptionSpecification)
 122     return true;
 123
 124   const FunctionProtoType *NewProto
 125     = New->getType()->getAs<FunctionProtoType>();
 126
 127   // The new function declaration is only missing an empty exception
 128   // specification "throw()". If the throw() specification came from a
 129   // function in a system header that has C linkage, just add an empty
 130   // exception specification to the "new" declaration. This is an
 131   // egregious workaround for glibc, which adds throw() specifications
 132   // to many libc functions as an optimization. Unfortunately, that
 133   // optimization isn't permitted by the C++ standard, so we're forced
 134   // to work around it here.
 135   if (MissingEmptyExceptionSpecification && NewProto &&
 136       (Old->getLocation().isInvalid() ||
 137        Context.getSourceManager().isInSystemHeader(Old->getLocation())) &&
 138       Old->isExternC()) {
 139     FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
 140     EPI.ExceptionSpecType = EST_DynamicNone;
 141     QualType NewType = Context.getFunctionType(NewProto->getResultType(),
 142                                                NewProto->arg_type_begin(),
 143                                                NewProto->getNumArgs(),
 144                                                EPI);
 145     New->setType(NewType);
 146     return false;
 147   }
 148
 149   if (MissingExceptionSpecification && NewProto) {
 150     const FunctionProtoType *OldProto
 151       = Old->getType()->getAs<FunctionProtoType>();
 152
 153     FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
 154     EPI.ExceptionSpecType = OldProto->getExceptionSpecType();
 155     if (EPI.ExceptionSpecType == EST_Dynamic) {
 156       EPI.NumExceptions = OldProto->getNumExceptions();
 157       EPI.Exceptions = OldProto->exception_begin();
 158     } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) {
 159       // FIXME: We can't just take the expression from the old prototype. It
 160       // likely contains references to the old prototype's parameters.
 161     }
 162
 163     // Update the type of the function with the appropriate exception
 164     // specification.
 165     QualType NewType = Context.getFunctionType(NewProto->getResultType(),
 166                                                NewProto->arg_type_begin(),
 167                                                NewProto->getNumArgs(),
 168                                                EPI);
 169     New->setType(NewType);
 170
 171     // If exceptions are disabled, suppress the warning about missing
 172     // exception specifications for new and delete operators.
 173     if (!getLangOptions().CXXExceptions) {
 174       switch (New->getDeclName().getCXXOverloadedOperator()) {
 175       case OO_New:
 176       case OO_Array_New:
 177       case OO_Delete:
 178       case OO_Array_Delete:
 179         if (New->getDeclContext()->isTranslationUnit())
 180           return false;
 181         break;
 182
 183       default:
 184         break;
 185       }
 186     }
 187
 188     // Warn about the lack of exception specification.
 189     llvm::SmallString<128> ExceptionSpecString;
 190     llvm::raw_svector_ostream OS(ExceptionSpecString);
 191     switch (OldProto->getExceptionSpecType()) {
 192     case EST_DynamicNone:
 193       OS << "throw()";
 194       break;
 195
 196     case EST_Dynamic: {
 197       OS << "throw(";
 198       bool OnFirstException = true;
 199       for (FunctionProtoType::exception_iterator E = OldProto->exception_begin(),
 200                                               EEnd = OldProto->exception_end();
 201            E != EEnd;
 202            ++E) {
 203         if (OnFirstException)
 204           OnFirstException = false;
 205         else
 206           OS << ", ";
 207
 208         OS << E->getAsString(getPrintingPolicy());
 209       }
 210       OS << ")";
 211       break;
 212     }
 213
 214     case EST_BasicNoexcept:
 215       OS << "noexcept";
 216       break;
 217
 218     case EST_ComputedNoexcept:
 219       OS << "noexcept(";
 220       OldProto->getNoexceptExpr()->printPretty(OS, Context, 0,
 221                                                getPrintingPolicy());
 222       OS << ")";
 223       break;
 224
 225     default:
 226       llvm_unreachable("This spec type is compatible with none.");
 227     }
 228     OS.flush();
 229
 230     SourceLocation FixItLoc;
 231     if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
 232       TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
 233       if (const FunctionTypeLoc *FTLoc = dyn_cast<FunctionTypeLoc>(&TL))
 234         FixItLoc = PP.getLocForEndOfToken(FTLoc->getLocalRangeEnd());
 235     }
 236
 237     if (FixItLoc.isInvalid())
 238       Diag(New->getLocation(), diag::warn_missing_exception_specification)
 239         << New << OS.str();
 240     else {
 241       // FIXME: This will get more complicated with C++0x
 242       // late-specified return types.
 243       Diag(New->getLocation(), diag::warn_missing_exception_specification)
 244         << New << OS.str()
 245         << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
 246     }
 247
 248     if (!Old->getLocation().isInvalid())
 249       Diag(Old->getLocation(), diag::note_previous_declaration);
 250
 251     return false;
 252   }
 253
 254   Diag(New->getLocation(), DiagID);
 255   Diag(Old->getLocation(), diag::note_previous_declaration);
 256   return true;
 257 }
 258
 259 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
 260 /// exception specifications. Exception specifications are equivalent if
 261 /// they allow exactly the same set of exception types. It does not matter how
 262 /// that is achieved. See C++ [except.spec]p2.
 263 bool Sema::CheckEquivalentExceptionSpec(
 264     const FunctionProtoType *Old, SourceLocation OldLoc,
 265     const FunctionProtoType *New, SourceLocation NewLoc) {
 266   unsigned DiagID = diag::err_mismatched_exception_spec;
 267   if (getLangOptions().MicrosoftExt)
 268     DiagID = diag::warn_mismatched_exception_spec;
 269   return CheckEquivalentExceptionSpec(
 270                                       PDiag(DiagID),
 271                                       PDiag(diag::note_previous_declaration),
 272                                       Old, OldLoc, New, NewLoc);
 273 }
 274
 275 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
 276 /// exception specifications. See C++ [except.spec]p3.
 277 bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID,
 278                                         const PartialDiagnostic & NoteID,
 279                                         const FunctionProtoType *Old,
 280                                         SourceLocation OldLoc,
 281                                         const FunctionProtoType *New,
 282                                         SourceLocation NewLoc,
 283                                         bool *MissingExceptionSpecification,
 284                                         bool*MissingEmptyExceptionSpecification,
 285                                         bool AllowNoexceptAllMatchWithNoSpec,
 286                                         bool IsOperatorNew) {
 287   // Just completely ignore this under -fno-exceptions.
 288   if (!getLangOptions().CXXExceptions)
 289     return false;
 290
 291   if (MissingExceptionSpecification)
 292     *MissingExceptionSpecification = false;
 293
 294   if (MissingEmptyExceptionSpecification)
 295     *MissingEmptyExceptionSpecification = false;
 296
 297   // C++0x [except.spec]p3: Two exception-specifications are compatible if:
 298   //   - both are non-throwing, regardless of their form,
 299   //   - both have the form noexcept(constant-expression) and the constant-
 300   //     expressions are equivalent,
 301   //   - both are dynamic-exception-specifications that have the same set of
 302   //     adjusted types.
 303   //
 304   // C++0x [except.spec]p12: An exception-specifcation is non-throwing if it is
 305   //   of the form throw(), noexcept, or noexcept(constant-expression) where the
 306   //   constant-expression yields true.
 307   //
 308   // C++0x [except.spec]p4: If any declaration of a function has an exception-
 309   //   specifier that is not a noexcept-specification allowing all exceptions,
 310   //   all declarations [...] of that function shall have a compatible
 311   //   exception-specification.
 312   //
 313   // That last point basically means that noexcept(false) matches no spec.
 314   // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
 315
 316   ExceptionSpecificationType OldEST = Old->getExceptionSpecType();
 317   ExceptionSpecificationType NewEST = New->getExceptionSpecType();
 318
 319   assert(OldEST != EST_Delayed && NewEST != EST_Delayed &&
 320          "Shouldn't see unknown exception specifications here");
 321
 322   // Shortcut the case where both have no spec.
 323   if (OldEST == EST_None && NewEST == EST_None)
 324     return false;
 325
 326   FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context);
 327   FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context);
 328   if (OldNR == FunctionProtoType::NR_BadNoexcept ||
 329       NewNR == FunctionProtoType::NR_BadNoexcept)
 330     return false;
 331
 332   // Dependent noexcept specifiers are compatible with each other, but nothing
 333   // else.
 334   // One noexcept is compatible with another if the argument is the same
 335   if (OldNR == NewNR &&
 336       OldNR != FunctionProtoType::NR_NoNoexcept &&
 337       NewNR != FunctionProtoType::NR_NoNoexcept)
 338     return false;
 339   if (OldNR != NewNR &&
 340       OldNR != FunctionProtoType::NR_NoNoexcept &&
 341       NewNR != FunctionProtoType::NR_NoNoexcept) {
 342     Diag(NewLoc, DiagID);
 343     if (NoteID.getDiagID() != 0)
 344       Diag(OldLoc, NoteID);
 345     return true;
 346   }
 347
 348   // The MS extension throw(...) is compatible with itself.
 349   if (OldEST == EST_MSAny && NewEST == EST_MSAny)
 350     return false;
 351
 352   // It's also compatible with no spec.
 353   if ((OldEST == EST_None && NewEST == EST_MSAny) ||
 354       (OldEST == EST_MSAny && NewEST == EST_None))
 355     return false;
 356
 357   // It's also compatible with noexcept(false).
 358   if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw)
 359     return false;
 360   if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw)
 361     return false;
 362
 363   // As described above, noexcept(false) matches no spec only for functions.
 364   if (AllowNoexceptAllMatchWithNoSpec) {
 365     if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw)
 366       return false;
 367     if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw)
 368       return false;
 369   }
 370
 371   // Any non-throwing specifications are compatible.
 372   bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow ||
 373                         OldEST == EST_DynamicNone;
 374   bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow ||
 375                         NewEST == EST_DynamicNone;
 376   if (OldNonThrowing && NewNonThrowing)
 377     return false;
 378
 379   // As a special compatibility feature, under C++0x we accept no spec and
 380   // throw(std::bad_alloc) as equivalent for operator new and operator new[].
 381   // This is because the implicit declaration changed, but old code would break.
 382   if (getLangOptions().CPlusPlus0x && IsOperatorNew) {
 383     const FunctionProtoType *WithExceptions = 0;
 384     if (OldEST == EST_None && NewEST == EST_Dynamic)
 385       WithExceptions = New;
 386     else if (OldEST == EST_Dynamic && NewEST == EST_None)
 387       WithExceptions = Old;
 388     if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
 389       // One has no spec, the other throw(something). If that something is
 390       // std::bad_alloc, all conditions are met.
 391       QualType Exception = *WithExceptions->exception_begin();
 392       if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
 393         IdentifierInfo* Name = ExRecord->getIdentifier();
 394         if (Name && Name->getName() == "bad_alloc") {
 395           // It's called bad_alloc, but is it in std?
 396           DeclContext* DC = ExRecord->getDeclContext();
 397           DC = DC->getEnclosingNamespaceContext();
 398           if (NamespaceDecl* NS = dyn_cast<NamespaceDecl>(DC)) {
 399             IdentifierInfo* NSName = NS->getIdentifier();
 400             DC = DC->getParent();
 401             if (NSName && NSName->getName() == "std" &&
 402                 DC->getEnclosingNamespaceContext()->isTranslationUnit()) {
 403               return false;
 404             }
 405           }
 406         }
 407       }
 408     }
 409   }
 410
 411   // At this point, the only remaining valid case is two matching dynamic
 412   // specifications. We return here unless both specifications are dynamic.
 413   if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) {
 414     if (MissingExceptionSpecification && Old->hasExceptionSpec() &&
 415         !New->hasExceptionSpec()) {
 416       // The old type has an exception specification of some sort, but
 417       // the new type does not.
 418       *MissingExceptionSpecification = true;
 419
 420       if (MissingEmptyExceptionSpecification && OldNonThrowing) {
 421         // The old type has a throw() or noexcept(true) exception specification
 422         // and the new type has no exception specification, and the caller asked
 423         // to handle this itself.
 424         *MissingEmptyExceptionSpecification = true;
 425       }
 426
 427       return true;
 428     }
 429
 430     Diag(NewLoc, DiagID);
 431     if (NoteID.getDiagID() != 0)
 432       Diag(OldLoc, NoteID);
 433     return true;
 434   }
 435
 436   assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic &&
 437       "Exception compatibility logic error: non-dynamic spec slipped through.");
 438
 439   bool Success = true;
 440   // Both have a dynamic exception spec. Collect the first set, then compare
 441   // to the second.
 442   llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
 443   for (FunctionProtoType::exception_iterator I = Old->exception_begin(),
 444        E = Old->exception_end(); I != E; ++I)
 445     OldTypes.insert(Context.getCanonicalType(*I).getUnqualifiedType());
 446
 447   for (FunctionProtoType::exception_iterator I = New->exception_begin(),
 448        E = New->exception_end(); I != E && Success; ++I) {
 449     CanQualType TypePtr = Context.getCanonicalType(*I).getUnqualifiedType();
 450     if(OldTypes.count(TypePtr))
 451       NewTypes.insert(TypePtr);
 452     else
 453       Success = false;
 454   }
 455
 456   Success = Success && OldTypes.size() == NewTypes.size();
 457
 458   if (Success) {
 459     return false;
 460   }
 461   Diag(NewLoc, DiagID);
 462   if (NoteID.getDiagID() != 0)
 463     Diag(OldLoc, NoteID);
 464   return true;
 465 }
 466
 467 /// CheckExceptionSpecSubset - Check whether the second function type's
 468 /// exception specification is a subset (or equivalent) of the first function
 469 /// type. This is used by override and pointer assignment checks.
 470 bool Sema::CheckExceptionSpecSubset(
 471     const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
 472     const FunctionProtoType *Superset, SourceLocation SuperLoc,
 473     const FunctionProtoType *Subset, SourceLocation SubLoc) {
 474
 475   // Just auto-succeed under -fno-exceptions.
 476   if (!getLangOptions().CXXExceptions)
 477     return false;
 478
 479   // FIXME: As usual, we could be more specific in our error messages, but
 480   // that better waits until we've got types with source locations.
 481
 482   if (!SubLoc.isValid())
 483     SubLoc = SuperLoc;
 484
 485   ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
 486
 487   // If superset contains everything, we're done.
 488   if (SuperEST == EST_None || SuperEST == EST_MSAny)
 489     return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
 490
 491   // If there are dependent noexcept specs, assume everything is fine. Unlike
 492   // with the equivalency check, this is safe in this case, because we don't
 493   // want to merge declarations. Checks after instantiation will catch any
 494   // omissions we make here.
 495   // We also shortcut checking if a noexcept expression was bad.
 496
 497   FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context);
 498   if (SuperNR == FunctionProtoType::NR_BadNoexcept ||
 499       SuperNR == FunctionProtoType::NR_Dependent)
 500     return false;
 501
 502   // Another case of the superset containing everything.
 503   if (SuperNR == FunctionProtoType::NR_Throw)
 504     return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
 505
 506   ExceptionSpecificationType SubEST = Subset->getExceptionSpecType();
 507
 508   assert(SuperEST != EST_Delayed && SubEST != EST_Delayed &&
 509          "Shouldn't see unknown exception specifications here");
 510
 511   // It does not. If the subset contains everything, we've failed.
 512   if (SubEST == EST_None || SubEST == EST_MSAny) {
 513     Diag(SubLoc, DiagID);
 514     if (NoteID.getDiagID() != 0)
 515       Diag(SuperLoc, NoteID);
 516     return true;
 517   }
 518
 519   FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context);
 520   if (SubNR == FunctionProtoType::NR_BadNoexcept ||
 521       SubNR == FunctionProtoType::NR_Dependent)
 522     return false;
 523
 524   // Another case of the subset containing everything.
 525   if (SubNR == FunctionProtoType::NR_Throw) {
 526     Diag(SubLoc, DiagID);
 527     if (NoteID.getDiagID() != 0)
 528       Diag(SuperLoc, NoteID);
 529     return true;
 530   }
 531
 532   // If the subset contains nothing, we're done.
 533   if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow)
 534     return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
 535
 536   // Otherwise, if the superset contains nothing, we've failed.
 537   if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) {
 538     Diag(SubLoc, DiagID);
 539     if (NoteID.getDiagID() != 0)
 540       Diag(SuperLoc, NoteID);
 541     return true;
 542   }
 543
 544   assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
 545          "Exception spec subset: non-dynamic case slipped through.");
 546
 547   // Neither contains everything or nothing. Do a proper comparison.
 548   for (FunctionProtoType::exception_iterator SubI = Subset->exception_begin(),
 549        SubE = Subset->exception_end(); SubI != SubE; ++SubI) {
 550     // Take one type from the subset.
 551     QualType CanonicalSubT = Context.getCanonicalType(*SubI);
 552     // Unwrap pointers and references so that we can do checks within a class
 553     // hierarchy. Don't unwrap member pointers; they don't have hierarchy
 554     // conversions on the pointee.
 555     bool SubIsPointer = false;
 556     if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>())
 557       CanonicalSubT = RefTy->getPointeeType();
 558     if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) {
 559       CanonicalSubT = PtrTy->getPointeeType();
 560       SubIsPointer = true;
 561     }
 562     bool SubIsClass = CanonicalSubT->isRecordType();
 563     CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType();
 564
 565     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
 566                        /*DetectVirtual=*/false);
 567
 568     bool Contained = false;
 569     // Make sure it's in the superset.
 570     for (FunctionProtoType::exception_iterator SuperI =
 571            Superset->exception_begin(), SuperE = Superset->exception_end();
 572          SuperI != SuperE; ++SuperI) {
 573       QualType CanonicalSuperT = Context.getCanonicalType(*SuperI);
 574       // SubT must be SuperT or derived from it, or pointer or reference to
 575       // such types.
 576       if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>())
 577         CanonicalSuperT = RefTy->getPointeeType();
 578       if (SubIsPointer) {
 579         if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>())
 580           CanonicalSuperT = PtrTy->getPointeeType();
 581         else {
 582           continue;
 583         }
 584       }
 585       CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType();
 586       // If the types are the same, move on to the next type in the subset.
 587       if (CanonicalSubT == CanonicalSuperT) {
 588         Contained = true;
 589         break;
 590       }
 591
 592       // Otherwise we need to check the inheritance.
 593       if (!SubIsClass || !CanonicalSuperT->isRecordType())
 594         continue;
 595
 596       Paths.clear();
 597       if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths))
 598         continue;
 599
 600       if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT)))
 601         continue;
 602
 603       // Do this check from a context without privileges.
 604       switch (CheckBaseClassAccess(SourceLocation(),
 605                                    CanonicalSuperT, CanonicalSubT,
 606                                    Paths.front(),
 607                                    /*Diagnostic*/ 0,
 608                                    /*ForceCheck*/ true,
 609                                    /*ForceUnprivileged*/ true)) {
 610       case AR_accessible: break;
 611       case AR_inaccessible: continue;
 612       case AR_dependent:
 613         llvm_unreachable("access check dependent for unprivileged context");
 614         break;
 615       case AR_delayed:
 616         llvm_unreachable("access check delayed in non-declaration");
 617         break;
 618       }
 619
 620       Contained = true;
 621       break;
 622     }
 623     if (!Contained) {
 624       Diag(SubLoc, DiagID);
 625       if (NoteID.getDiagID() != 0)
 626         Diag(SuperLoc, NoteID);
 627       return true;
 628     }
 629   }
 630   // We've run half the gauntlet.
 631   return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
 632 }
 633
 634 static bool CheckSpecForTypesEquivalent(Sema &S,
 635     const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
 636     QualType Target, SourceLocation TargetLoc,
 637     QualType Source, SourceLocation SourceLoc)
 638 {
 639   const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
 640   if (!TFunc)
 641     return false;
 642   const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
 643   if (!SFunc)
 644     return false;
 645
 646   return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
 647                                         SFunc, SourceLoc);
 648 }
 649
 650 /// CheckParamExceptionSpec - Check if the parameter and return types of the
 651 /// two functions have equivalent exception specs. This is part of the
 652 /// assignment and override compatibility check. We do not check the parameters
 653 /// of parameter function pointers recursively, as no sane programmer would
 654 /// even be able to write such a function type.
 655 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic & NoteID,
 656     const FunctionProtoType *Target, SourceLocation TargetLoc,
 657     const FunctionProtoType *Source, SourceLocation SourceLoc)
 658 {
 659   if (CheckSpecForTypesEquivalent(*this,
 660                            PDiag(diag::err_deep_exception_specs_differ) << 0,
 661                                   PDiag(),
 662                                   Target->getResultType(), TargetLoc,
 663                                   Source->getResultType(), SourceLoc))
 664     return true;
 665
 666   // We shouldn't even be testing this unless the arguments are otherwise
 667   // compatible.
 668   assert(Target->getNumArgs() == Source->getNumArgs() &&
 669          "Functions have different argument counts.");
 670   for (unsigned i = 0, E = Target->getNumArgs(); i != E; ++i) {
 671     if (CheckSpecForTypesEquivalent(*this,
 672                            PDiag(diag::err_deep_exception_specs_differ) << 1,
 673                                     PDiag(),
 674                                     Target->getArgType(i), TargetLoc,
 675                                     Source->getArgType(i), SourceLoc))
 676       return true;
 677   }
 678   return false;
 679 }
 680
 681 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
 682 {
 683   // First we check for applicability.
 684   // Target type must be a function, function pointer or function reference.
 685   const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
 686   if (!ToFunc)
 687     return false;
 688
 689   // SourceType must be a function or function pointer.
 690   const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
 691   if (!FromFunc)
 692     return false;
 693
 694   // Now we've got the correct types on both sides, check their compatibility.
 695   // This means that the source of the conversion can only throw a subset of
 696   // the exceptions of the target, and any exception specs on arguments or
 697   // return types must be equivalent.
 698   return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs),
 699                                   PDiag(), ToFunc,
 700                                   From->getSourceRange().getBegin(),
 701                                   FromFunc, SourceLocation());
 702 }
 703
 704 bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
 705                                                 const CXXMethodDecl *Old) {
 706   if (getLangOptions().CPlusPlus0x && isa<CXXDestructorDecl>(New)) {
 707     // Don't check uninstantiated template destructors at all. We can only
 708     // synthesize correct specs after the template is instantiated.
 709     if (New->getParent()->isDependentType())
 710       return false;
 711     if (New->getParent()->isBeingDefined()) {
 712       // The destructor might be updated once the definition is finished. So
 713       // remember it and check later.
 714       DelayedDestructorExceptionSpecChecks.push_back(std::make_pair(
 715         cast<CXXDestructorDecl>(New), cast<CXXDestructorDecl>(Old)));
 716       return false;
 717     }
 718   }
 719   unsigned DiagID = diag::err_override_exception_spec;
 720   if (getLangOptions().MicrosoftExt)
 721     DiagID = diag::warn_override_exception_spec;
 722   return CheckExceptionSpecSubset(PDiag(DiagID),
 723                                   PDiag(diag::note_overridden_virtual_function),
 724                                   Old->getType()->getAs<FunctionProtoType>(),
 725                                   Old->getLocation(),
 726                                   New->getType()->getAs<FunctionProtoType>(),
 727                                   New->getLocation());
 728 }
 729
 730 } // end namespace clang