clang  6.0.0svn
SemaExceptionSpec.cpp
Go to the documentation of this file.
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 
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/TypeLoc.h"
20 #include "clang/Basic/Diagnostic.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/SmallString.h"
24 
25 namespace clang {
26 
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.
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 or std::__debug or
47  // std::__profile.
48  if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
49  !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
50  return false;
51 
52  auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
53  if (!ND)
54  return false;
55 
56  bool IsInStd = ND->isStdNamespace();
57  if (!IsInStd) {
58  // This isn't a direct member of namespace std, but it might still be
59  // libstdc++'s std::__debug::array or std::__profile::array.
60  IdentifierInfo *II = ND->getIdentifier();
61  if (!II || !(II->isStr("__debug") || II->isStr("__profile")) ||
62  !ND->isInStdNamespace())
63  return false;
64  }
65 
66  // Only apply this hack within a system header.
68  return false;
69 
70  return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
71  .Case("array", true)
72  .Case("pair", IsInStd)
73  .Case("priority_queue", IsInStd)
74  .Case("stack", IsInStd)
75  .Case("queue", IsInStd)
76  .Default(false);
77 }
78 
79 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
80 /// exception specification. Incomplete types, or pointers to incomplete types
81 /// other than void are not allowed.
82 ///
83 /// \param[in,out] T The exception type. This will be decayed to a pointer type
84 /// when the input is an array or a function type.
86  // C++11 [except.spec]p2:
87  // A type cv T, "array of T", or "function returning T" denoted
88  // in an exception-specification is adjusted to type T, "pointer to T", or
89  // "pointer to function returning T", respectively.
90  //
91  // We also apply this rule in C++98.
92  if (T->isArrayType())
94  else if (T->isFunctionType())
95  T = Context.getPointerType(T);
96 
97  int Kind = 0;
98  QualType PointeeT = T;
99  if (const PointerType *PT = T->getAs<PointerType>()) {
100  PointeeT = PT->getPointeeType();
101  Kind = 1;
102 
103  // cv void* is explicitly permitted, despite being a pointer to an
104  // incomplete type.
105  if (PointeeT->isVoidType())
106  return false;
107  } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
108  PointeeT = RT->getPointeeType();
109  Kind = 2;
110 
111  if (RT->isRValueReferenceType()) {
112  // C++11 [except.spec]p2:
113  // A type denoted in an exception-specification shall not denote [...]
114  // an rvalue reference type.
115  Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
116  << T << Range;
117  return true;
118  }
119  }
120 
121  // C++11 [except.spec]p2:
122  // A type denoted in an exception-specification shall not denote an
123  // incomplete type other than a class currently being defined [...].
124  // A type denoted in an exception-specification shall not denote a
125  // pointer or reference to an incomplete type, other than (cv) void* or a
126  // pointer or reference to a class currently being defined.
127  // In Microsoft mode, downgrade this to a warning.
128  unsigned DiagID = diag::err_incomplete_in_exception_spec;
129  bool ReturnValueOnError = true;
130  if (getLangOpts().MicrosoftExt) {
131  DiagID = diag::ext_incomplete_in_exception_spec;
132  ReturnValueOnError = false;
133  }
134  if (!(PointeeT->isRecordType() &&
135  PointeeT->getAs<RecordType>()->isBeingDefined()) &&
136  RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
137  return ReturnValueOnError;
138 
139  return false;
140 }
141 
142 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
143 /// to member to a function with an exception specification. This means that
144 /// it is invalid to add another level of indirection.
146  // C++17 removes this rule in favor of putting exception specifications into
147  // the type system.
148  if (getLangOpts().CPlusPlus1z)
149  return false;
150 
151  if (const PointerType *PT = T->getAs<PointerType>())
152  T = PT->getPointeeType();
153  else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
154  T = PT->getPointeeType();
155  else
156  return false;
157 
158  const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
159  if (!FnT)
160  return false;
161 
162  return FnT->hasExceptionSpec();
163 }
164 
165 const FunctionProtoType *
167  if (FPT->getExceptionSpecType() == EST_Unparsed) {
168  Diag(Loc, diag::err_exception_spec_not_parsed);
169  return nullptr;
170  }
171 
173  return FPT;
174 
175  FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
176  const FunctionProtoType *SourceFPT =
177  SourceDecl->getType()->castAs<FunctionProtoType>();
178 
179  // If the exception specification has already been resolved, just return it.
181  return SourceFPT;
182 
183  // Compute or instantiate the exception specification now.
184  if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
185  EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl));
186  else
187  InstantiateExceptionSpec(Loc, SourceDecl);
188 
189  const FunctionProtoType *Proto =
190  SourceDecl->getType()->castAs<FunctionProtoType>();
191  if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
192  Diag(Loc, diag::err_exception_spec_not_parsed);
193  Proto = nullptr;
194  }
195  return Proto;
196 }
197 
198 void
201  // If we've fully resolved the exception specification, notify listeners.
203  if (auto *Listener = getASTMutationListener())
204  Listener->ResolvedExceptionSpec(FD);
205 
206  for (auto *Redecl : FD->redecls())
207  Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
208 }
209 
211  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
212  const FunctionProtoType *Old, SourceLocation OldLoc,
213  const FunctionProtoType *New, SourceLocation NewLoc,
214  bool *MissingExceptionSpecification = nullptr,
215  bool *MissingEmptyExceptionSpecification = nullptr,
216  bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false);
217 
218 /// Determine whether a function has an implicitly-generated exception
219 /// specification.
221  if (!isa<CXXDestructorDecl>(Decl) &&
222  Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
223  Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
224  return false;
225 
226  // For a function that the user didn't declare:
227  // - if this is a destructor, its exception specification is implicit.
228  // - if this is 'operator delete' or 'operator delete[]', the exception
229  // specification is as-if an explicit exception specification was given
230  // (per [basic.stc.dynamic]p2).
231  if (!Decl->getTypeSourceInfo())
232  return isa<CXXDestructorDecl>(Decl);
233 
234  const FunctionProtoType *Ty =
236  return !Ty->hasExceptionSpec();
237 }
238 
240  // Just completely ignore this under -fno-exceptions prior to C++1z.
241  // In C++1z onwards, the exception specification is part of the type and
242  // we will diagnose mismatches anyway, so it's better to check for them here.
243  if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus1z)
244  return false;
245 
247  bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
248  bool MissingExceptionSpecification = false;
249  bool MissingEmptyExceptionSpecification = false;
250 
251  unsigned DiagID = diag::err_mismatched_exception_spec;
252  bool ReturnValueOnError = true;
253  if (getLangOpts().MicrosoftExt) {
254  DiagID = diag::ext_mismatched_exception_spec;
255  ReturnValueOnError = false;
256  }
257 
258  // Check the types as written: they must match before any exception
259  // specification adjustment is applied.
261  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
262  Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
263  New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
264  &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
265  /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
266  // C++11 [except.spec]p4 [DR1492]:
267  // If a declaration of a function has an implicit
268  // exception-specification, other declarations of the function shall
269  // not specify an exception-specification.
270  if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions &&
272  Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
273  << hasImplicitExceptionSpec(Old);
274  if (Old->getLocation().isValid())
275  Diag(Old->getLocation(), diag::note_previous_declaration);
276  }
277  return false;
278  }
279 
280  // The failure was something other than an missing exception
281  // specification; return an error, except in MS mode where this is a warning.
282  if (!MissingExceptionSpecification)
283  return ReturnValueOnError;
284 
285  const FunctionProtoType *NewProto =
286  New->getType()->castAs<FunctionProtoType>();
287 
288  // The new function declaration is only missing an empty exception
289  // specification "throw()". If the throw() specification came from a
290  // function in a system header that has C linkage, just add an empty
291  // exception specification to the "new" declaration. Note that C library
292  // implementations are permitted to add these nothrow exception
293  // specifications.
294  //
295  // Likewise if the old function is a builtin.
296  if (MissingEmptyExceptionSpecification && NewProto &&
297  (Old->getLocation().isInvalid() ||
299  Old->getBuiltinID()) &&
300  Old->isExternC()) {
302  NewProto->getReturnType(), NewProto->getParamTypes(),
304  return false;
305  }
306 
307  const FunctionProtoType *OldProto =
308  Old->getType()->castAs<FunctionProtoType>();
309 
311  if (ESI.Type == EST_Dynamic) {
312  ESI.Exceptions = OldProto->exceptions();
313  }
314 
315  if (ESI.Type == EST_ComputedNoexcept) {
316  // For computed noexcept, we can't just take the expression from the old
317  // prototype. It likely contains references to the old prototype's
318  // parameters.
319  New->setInvalidDecl();
320  } else {
321  // Update the type of the function with the appropriate exception
322  // specification.
324  NewProto->getReturnType(), NewProto->getParamTypes(),
325  NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
326  }
327 
328  if (getLangOpts().MicrosoftExt && ESI.Type != EST_ComputedNoexcept) {
329  // Allow missing exception specifications in redeclarations as an extension.
330  DiagID = diag::ext_ms_missing_exception_specification;
331  ReturnValueOnError = false;
332  } else if (New->isReplaceableGlobalAllocationFunction() &&
333  ESI.Type != EST_ComputedNoexcept) {
334  // Allow missing exception specifications in redeclarations as an extension,
335  // when declaring a replaceable global allocation function.
336  DiagID = diag::ext_missing_exception_specification;
337  ReturnValueOnError = false;
338  } else {
339  DiagID = diag::err_missing_exception_specification;
340  ReturnValueOnError = true;
341  }
342 
343  // Warn about the lack of exception specification.
344  SmallString<128> ExceptionSpecString;
345  llvm::raw_svector_ostream OS(ExceptionSpecString);
346  switch (OldProto->getExceptionSpecType()) {
347  case EST_DynamicNone:
348  OS << "throw()";
349  break;
350 
351  case EST_Dynamic: {
352  OS << "throw(";
353  bool OnFirstException = true;
354  for (const auto &E : OldProto->exceptions()) {
355  if (OnFirstException)
356  OnFirstException = false;
357  else
358  OS << ", ";
359 
360  OS << E.getAsString(getPrintingPolicy());
361  }
362  OS << ")";
363  break;
364  }
365 
366  case EST_BasicNoexcept:
367  OS << "noexcept";
368  break;
369 
371  OS << "noexcept(";
372  assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
373  OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
374  OS << ")";
375  break;
376 
377  default:
378  llvm_unreachable("This spec type is compatible with none.");
379  }
380 
381  SourceLocation FixItLoc;
382  if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
383  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
384  // FIXME: Preserve enough information so that we can produce a correct fixit
385  // location when there is a trailing return type.
386  if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>())
387  if (!FTLoc.getTypePtr()->hasTrailingReturn())
388  FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
389  }
390 
391  if (FixItLoc.isInvalid())
392  Diag(New->getLocation(), DiagID)
393  << New << OS.str();
394  else {
395  Diag(New->getLocation(), DiagID)
396  << New << OS.str()
397  << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
398  }
399 
400  if (Old->getLocation().isValid())
401  Diag(Old->getLocation(), diag::note_previous_declaration);
402 
403  return ReturnValueOnError;
404 }
405 
406 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
407 /// exception specifications. Exception specifications are equivalent if
408 /// they allow exactly the same set of exception types. It does not matter how
409 /// that is achieved. See C++ [except.spec]p2.
411  const FunctionProtoType *Old, SourceLocation OldLoc,
412  const FunctionProtoType *New, SourceLocation NewLoc) {
413  if (!getLangOpts().CXXExceptions)
414  return false;
415 
416  unsigned DiagID = diag::err_mismatched_exception_spec;
417  if (getLangOpts().MicrosoftExt)
418  DiagID = diag::ext_mismatched_exception_spec;
420  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
421  Old, OldLoc, New, NewLoc);
422 
423  // In Microsoft mode, mismatching exception specifications just cause a warning.
424  if (getLangOpts().MicrosoftExt)
425  return false;
426  return Result;
427 }
428 
429 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
430 /// exception specifications. See C++ [except.spec]p3.
431 ///
432 /// \return \c false if the exception specifications match, \c true if there is
433 /// a problem. If \c true is returned, either a diagnostic has already been
434 /// produced or \c *MissingExceptionSpecification is set to \c true.
436  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
437  const FunctionProtoType *Old, SourceLocation OldLoc,
438  const FunctionProtoType *New, SourceLocation NewLoc,
439  bool *MissingExceptionSpecification,
440  bool *MissingEmptyExceptionSpecification,
441  bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) {
442  if (MissingExceptionSpecification)
443  *MissingExceptionSpecification = false;
444 
445  if (MissingEmptyExceptionSpecification)
446  *MissingEmptyExceptionSpecification = false;
447 
448  Old = S.ResolveExceptionSpec(NewLoc, Old);
449  if (!Old)
450  return false;
451  New = S.ResolveExceptionSpec(NewLoc, New);
452  if (!New)
453  return false;
454 
455  // C++0x [except.spec]p3: Two exception-specifications are compatible if:
456  // - both are non-throwing, regardless of their form,
457  // - both have the form noexcept(constant-expression) and the constant-
458  // expressions are equivalent,
459  // - both are dynamic-exception-specifications that have the same set of
460  // adjusted types.
461  //
462  // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
463  // of the form throw(), noexcept, or noexcept(constant-expression) where the
464  // constant-expression yields true.
465  //
466  // C++0x [except.spec]p4: If any declaration of a function has an exception-
467  // specifier that is not a noexcept-specification allowing all exceptions,
468  // all declarations [...] of that function shall have a compatible
469  // exception-specification.
470  //
471  // That last point basically means that noexcept(false) matches no spec.
472  // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
473 
476 
477  assert(!isUnresolvedExceptionSpec(OldEST) &&
478  !isUnresolvedExceptionSpec(NewEST) &&
479  "Shouldn't see unknown exception specifications here");
480 
481  // Shortcut the case where both have no spec.
482  if (OldEST == EST_None && NewEST == EST_None)
483  return false;
484 
487  if (OldNR == FunctionProtoType::NR_BadNoexcept ||
489  return false;
490 
491  // Dependent noexcept specifiers are compatible with each other, but nothing
492  // else.
493  // One noexcept is compatible with another if the argument is the same
494  if (OldNR == NewNR &&
497  return false;
498  if (OldNR != NewNR &&
501  S.Diag(NewLoc, DiagID);
502  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
503  S.Diag(OldLoc, NoteID);
504  return true;
505  }
506 
507  // The MS extension throw(...) is compatible with itself.
508  if (OldEST == EST_MSAny && NewEST == EST_MSAny)
509  return false;
510 
511  // It's also compatible with no spec.
512  if ((OldEST == EST_None && NewEST == EST_MSAny) ||
513  (OldEST == EST_MSAny && NewEST == EST_None))
514  return false;
515 
516  // It's also compatible with noexcept(false).
517  if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw)
518  return false;
519  if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw)
520  return false;
521 
522  // As described above, noexcept(false) matches no spec only for functions.
523  if (AllowNoexceptAllMatchWithNoSpec) {
524  if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw)
525  return false;
526  if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw)
527  return false;
528  }
529 
530  // Any non-throwing specifications are compatible.
531  bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow ||
532  OldEST == EST_DynamicNone;
533  bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow ||
534  NewEST == EST_DynamicNone;
535  if (OldNonThrowing && NewNonThrowing)
536  return false;
537 
538  // As a special compatibility feature, under C++0x we accept no spec and
539  // throw(std::bad_alloc) as equivalent for operator new and operator new[].
540  // This is because the implicit declaration changed, but old code would break.
541  if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) {
542  const FunctionProtoType *WithExceptions = nullptr;
543  if (OldEST == EST_None && NewEST == EST_Dynamic)
544  WithExceptions = New;
545  else if (OldEST == EST_Dynamic && NewEST == EST_None)
546  WithExceptions = Old;
547  if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
548  // One has no spec, the other throw(something). If that something is
549  // std::bad_alloc, all conditions are met.
550  QualType Exception = *WithExceptions->exception_begin();
551  if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
552  IdentifierInfo* Name = ExRecord->getIdentifier();
553  if (Name && Name->getName() == "bad_alloc") {
554  // It's called bad_alloc, but is it in std?
555  if (ExRecord->isInStdNamespace()) {
556  return false;
557  }
558  }
559  }
560  }
561  }
562 
563  // At this point, the only remaining valid case is two matching dynamic
564  // specifications. We return here unless both specifications are dynamic.
565  if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) {
566  if (MissingExceptionSpecification && Old->hasExceptionSpec() &&
567  !New->hasExceptionSpec()) {
568  // The old type has an exception specification of some sort, but
569  // the new type does not.
570  *MissingExceptionSpecification = true;
571 
572  if (MissingEmptyExceptionSpecification && OldNonThrowing) {
573  // The old type has a throw() or noexcept(true) exception specification
574  // and the new type has no exception specification, and the caller asked
575  // to handle this itself.
576  *MissingEmptyExceptionSpecification = true;
577  }
578 
579  return true;
580  }
581 
582  S.Diag(NewLoc, DiagID);
583  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
584  S.Diag(OldLoc, NoteID);
585  return true;
586  }
587 
588  assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic &&
589  "Exception compatibility logic error: non-dynamic spec slipped through.");
590 
591  bool Success = true;
592  // Both have a dynamic exception spec. Collect the first set, then compare
593  // to the second.
594  llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
595  for (const auto &I : Old->exceptions())
596  OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
597 
598  for (const auto &I : New->exceptions()) {
600  if (OldTypes.count(TypePtr))
601  NewTypes.insert(TypePtr);
602  else
603  Success = false;
604  }
605 
606  Success = Success && OldTypes.size() == NewTypes.size();
607 
608  if (Success) {
609  return false;
610  }
611  S.Diag(NewLoc, DiagID);
612  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
613  S.Diag(OldLoc, NoteID);
614  return true;
615 }
616 
618  const PartialDiagnostic &NoteID,
619  const FunctionProtoType *Old,
620  SourceLocation OldLoc,
621  const FunctionProtoType *New,
622  SourceLocation NewLoc) {
623  if (!getLangOpts().CXXExceptions)
624  return false;
625  return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc,
626  New, NewLoc);
627 }
628 
629 /// CheckExceptionSpecSubset - Check whether the second function type's
630 /// exception specification is a subset (or equivalent) of the first function
631 /// type. This is used by override and pointer assignment checks.
633  const PartialDiagnostic &NestedDiagID,
634  const PartialDiagnostic &NoteID,
635  const FunctionProtoType *Superset,
636  SourceLocation SuperLoc,
637  const FunctionProtoType *Subset,
638  SourceLocation SubLoc) {
639 
640  // Just auto-succeed under -fno-exceptions.
641  if (!getLangOpts().CXXExceptions)
642  return false;
643 
644  // FIXME: As usual, we could be more specific in our error messages, but
645  // that better waits until we've got types with source locations.
646 
647  if (!SubLoc.isValid())
648  SubLoc = SuperLoc;
649 
650  // Resolve the exception specifications, if needed.
651  Superset = ResolveExceptionSpec(SuperLoc, Superset);
652  if (!Superset)
653  return false;
654  Subset = ResolveExceptionSpec(SubLoc, Subset);
655  if (!Subset)
656  return false;
657 
658  ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
659 
660  // If superset contains everything, we're done.
661  if (SuperEST == EST_None || SuperEST == EST_MSAny)
662  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
663  Subset, SubLoc);
664 
665  // If there are dependent noexcept specs, assume everything is fine. Unlike
666  // with the equivalency check, this is safe in this case, because we don't
667  // want to merge declarations. Checks after instantiation will catch any
668  // omissions we make here.
669  // We also shortcut checking if a noexcept expression was bad.
670 
672  if (SuperNR == FunctionProtoType::NR_BadNoexcept ||
674  return false;
675 
676  // Another case of the superset containing everything.
677  if (SuperNR == FunctionProtoType::NR_Throw)
678  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
679  Subset, SubLoc);
680 
682 
683  assert(!isUnresolvedExceptionSpec(SuperEST) &&
684  !isUnresolvedExceptionSpec(SubEST) &&
685  "Shouldn't see unknown exception specifications here");
686 
687  // It does not. If the subset contains everything, we've failed.
688  if (SubEST == EST_None || SubEST == EST_MSAny) {
689  Diag(SubLoc, DiagID);
690  if (NoteID.getDiagID() != 0)
691  Diag(SuperLoc, NoteID);
692  return true;
693  }
694 
696  if (SubNR == FunctionProtoType::NR_BadNoexcept ||
698  return false;
699 
700  // Another case of the subset containing everything.
701  if (SubNR == FunctionProtoType::NR_Throw) {
702  Diag(SubLoc, DiagID);
703  if (NoteID.getDiagID() != 0)
704  Diag(SuperLoc, NoteID);
705  return true;
706  }
707 
708  // If the subset contains nothing, we're done.
709  if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow)
710  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
711  Subset, SubLoc);
712 
713  // Otherwise, if the superset contains nothing, we've failed.
714  if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) {
715  Diag(SubLoc, DiagID);
716  if (NoteID.getDiagID() != 0)
717  Diag(SuperLoc, NoteID);
718  return true;
719  }
720 
721  assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
722  "Exception spec subset: non-dynamic case slipped through.");
723 
724  // Neither contains everything or nothing. Do a proper comparison.
725  for (const auto &SubI : Subset->exceptions()) {
726  // Take one type from the subset.
727  QualType CanonicalSubT = Context.getCanonicalType(SubI);
728  // Unwrap pointers and references so that we can do checks within a class
729  // hierarchy. Don't unwrap member pointers; they don't have hierarchy
730  // conversions on the pointee.
731  bool SubIsPointer = false;
732  if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>())
733  CanonicalSubT = RefTy->getPointeeType();
734  if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) {
735  CanonicalSubT = PtrTy->getPointeeType();
736  SubIsPointer = true;
737  }
738  bool SubIsClass = CanonicalSubT->isRecordType();
739  CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType();
740 
741  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
742  /*DetectVirtual=*/false);
743 
744  bool Contained = false;
745  // Make sure it's in the superset.
746  for (const auto &SuperI : Superset->exceptions()) {
747  QualType CanonicalSuperT = Context.getCanonicalType(SuperI);
748  // SubT must be SuperT or derived from it, or pointer or reference to
749  // such types.
750  if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>())
751  CanonicalSuperT = RefTy->getPointeeType();
752  if (SubIsPointer) {
753  if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>())
754  CanonicalSuperT = PtrTy->getPointeeType();
755  else {
756  continue;
757  }
758  }
759  CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType();
760  // If the types are the same, move on to the next type in the subset.
761  if (CanonicalSubT == CanonicalSuperT) {
762  Contained = true;
763  break;
764  }
765 
766  // Otherwise we need to check the inheritance.
767  if (!SubIsClass || !CanonicalSuperT->isRecordType())
768  continue;
769 
770  Paths.clear();
771  if (!IsDerivedFrom(SubLoc, CanonicalSubT, CanonicalSuperT, Paths))
772  continue;
773 
774  if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT)))
775  continue;
776 
777  // Do this check from a context without privileges.
779  CanonicalSuperT, CanonicalSubT,
780  Paths.front(),
781  /*Diagnostic*/ 0,
782  /*ForceCheck*/ true,
783  /*ForceUnprivileged*/ true)) {
784  case AR_accessible: break;
785  case AR_inaccessible: continue;
786  case AR_dependent:
787  llvm_unreachable("access check dependent for unprivileged context");
788  case AR_delayed:
789  llvm_unreachable("access check delayed in non-declaration");
790  }
791 
792  Contained = true;
793  break;
794  }
795  if (!Contained) {
796  Diag(SubLoc, DiagID);
797  if (NoteID.getDiagID() != 0)
798  Diag(SuperLoc, NoteID);
799  return true;
800  }
801  }
802  // We've run half the gauntlet.
803  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
804  Subset, SubLoc);
805 }
806 
807 static bool
809  const PartialDiagnostic &NoteID, QualType Target,
810  SourceLocation TargetLoc, QualType Source,
811  SourceLocation SourceLoc) {
812  const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
813  if (!TFunc)
814  return false;
815  const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
816  if (!SFunc)
817  return false;
818 
819  return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
820  SFunc, SourceLoc);
821 }
822 
823 /// CheckParamExceptionSpec - Check if the parameter and return types of the
824 /// two functions have equivalent exception specs. This is part of the
825 /// assignment and override compatibility check. We do not check the parameters
826 /// of parameter function pointers recursively, as no sane programmer would
827 /// even be able to write such a function type.
829  const PartialDiagnostic &NoteID,
830  const FunctionProtoType *Target,
831  SourceLocation TargetLoc,
832  const FunctionProtoType *Source,
833  SourceLocation SourceLoc) {
834  auto RetDiag = DiagID;
835  RetDiag << 0;
837  *this, RetDiag, PDiag(),
838  Target->getReturnType(), TargetLoc, Source->getReturnType(),
839  SourceLoc))
840  return true;
841 
842  // We shouldn't even be testing this unless the arguments are otherwise
843  // compatible.
844  assert(Target->getNumParams() == Source->getNumParams() &&
845  "Functions have different argument counts.");
846  for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
847  auto ParamDiag = DiagID;
848  ParamDiag << 1;
850  *this, ParamDiag, PDiag(),
851  Target->getParamType(i), TargetLoc, Source->getParamType(i),
852  SourceLoc))
853  return true;
854  }
855  return false;
856 }
857 
859  // First we check for applicability.
860  // Target type must be a function, function pointer or function reference.
861  const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
862  if (!ToFunc || ToFunc->hasDependentExceptionSpec())
863  return false;
864 
865  // SourceType must be a function or function pointer.
866  const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
867  if (!FromFunc || FromFunc->hasDependentExceptionSpec())
868  return false;
869 
870  unsigned DiagID = diag::err_incompatible_exception_specs;
871  unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
872  // This is not an error in C++17 onwards, unless the noexceptness doesn't
873  // match, but in that case we have a full-on type mismatch, not just a
874  // type sugar mismatch.
875  if (getLangOpts().CPlusPlus1z) {
876  DiagID = diag::warn_incompatible_exception_specs;
877  NestedDiagID = diag::warn_deep_exception_specs_differ;
878  }
879 
880  // Now we've got the correct types on both sides, check their compatibility.
881  // This means that the source of the conversion can only throw a subset of
882  // the exceptions of the target, and any exception specs on arguments or
883  // return types must be equivalent.
884  //
885  // FIXME: If there is a nested dependent exception specification, we should
886  // not be checking it here. This is fine:
887  // template<typename T> void f() {
888  // void (*p)(void (*) throw(T));
889  // void (*q)(void (*) throw(int)) = p;
890  // }
891  // ... because it might be instantiated with T=int.
892  return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(NestedDiagID), PDiag(),
893  ToFunc, From->getSourceRange().getBegin(),
894  FromFunc, SourceLocation()) &&
895  !getLangOpts().CPlusPlus1z;
896 }
897 
899  const CXXMethodDecl *Old) {
900  // If the new exception specification hasn't been parsed yet, skip the check.
901  // We'll get called again once it's been parsed.
902  if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
903  EST_Unparsed)
904  return false;
905  if (getLangOpts().CPlusPlus11 && isa<CXXDestructorDecl>(New)) {
906  // Don't check uninstantiated template destructors at all. We can only
907  // synthesize correct specs after the template is instantiated.
908  if (New->getParent()->isDependentType())
909  return false;
910  if (New->getParent()->isBeingDefined()) {
911  // The destructor might be updated once the definition is finished. So
912  // remember it and check later.
913  DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
914  return false;
915  }
916  }
917  // If the old exception specification hasn't been parsed yet, remember that
918  // we need to perform this check when we get to the end of the outermost
919  // lexically-surrounding class.
920  if (Old->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
921  EST_Unparsed) {
922  DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
923  return false;
924  }
925  unsigned DiagID = diag::err_override_exception_spec;
926  if (getLangOpts().MicrosoftExt)
927  DiagID = diag::ext_override_exception_spec;
928  return CheckExceptionSpecSubset(PDiag(DiagID),
929  PDiag(diag::err_deep_exception_specs_differ),
930  PDiag(diag::note_overridden_virtual_function),
931  Old->getType()->getAs<FunctionProtoType>(),
932  Old->getLocation(),
933  New->getType()->getAs<FunctionProtoType>(),
934  New->getLocation());
935 }
936 
937 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) {
939  for (const Stmt *SubStmt : E->children()) {
940  R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
941  if (R == CT_Can)
942  break;
943  }
944  return R;
945 }
946 
947 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
948  // As an extension, we assume that __attribute__((nothrow)) functions don't
949  // throw.
950  if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
951  return CT_Cannot;
952 
953  QualType T;
954 
955  // In C++1z, just look at the function type of the callee.
956  if (S.getLangOpts().CPlusPlus1z && isa<CallExpr>(E)) {
957  E = cast<CallExpr>(E)->getCallee();
958  T = E->getType();
959  if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
960  // Sadly we don't preserve the actual type as part of the "bound member"
961  // placeholder, so we need to reconstruct it.
962  E = E->IgnoreParenImpCasts();
963 
964  // Could be a call to a pointer-to-member or a plain member access.
965  if (auto *Op = dyn_cast<BinaryOperator>(E)) {
966  assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
967  T = Op->getRHS()->getType()
968  ->castAs<MemberPointerType>()->getPointeeType();
969  } else {
970  T = cast<MemberExpr>(E)->getMemberDecl()->getType();
971  }
972  }
973  } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
974  T = VD->getType();
975  else
976  // If we have no clue what we're calling, assume the worst.
977  return CT_Can;
978 
979  const FunctionProtoType *FT;
980  if ((FT = T->getAs<FunctionProtoType>())) {
981  } else if (const PointerType *PT = T->getAs<PointerType>())
982  FT = PT->getPointeeType()->getAs<FunctionProtoType>();
983  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
984  FT = RT->getPointeeType()->getAs<FunctionProtoType>();
985  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
986  FT = MT->getPointeeType()->getAs<FunctionProtoType>();
987  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
988  FT = BT->getPointeeType()->getAs<FunctionProtoType>();
989 
990  if (!FT)
991  return CT_Can;
992 
993  FT = S.ResolveExceptionSpec(E->getLocStart(), FT);
994  if (!FT)
995  return CT_Can;
996 
997  return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
998 }
999 
1001  if (DC->isTypeDependent())
1002  return CT_Dependent;
1003 
1004  if (!DC->getTypeAsWritten()->isReferenceType())
1005  return CT_Cannot;
1006 
1007  if (DC->getSubExpr()->isTypeDependent())
1008  return CT_Dependent;
1009 
1010  return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
1011 }
1012 
1014  if (DC->isTypeOperand())
1015  return CT_Cannot;
1016 
1017  Expr *Op = DC->getExprOperand();
1018  if (Op->isTypeDependent())
1019  return CT_Dependent;
1020 
1021  const RecordType *RT = Op->getType()->getAs<RecordType>();
1022  if (!RT)
1023  return CT_Cannot;
1024 
1025  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1026  return CT_Cannot;
1027 
1028  if (Op->Classify(S.Context).isPRValue())
1029  return CT_Cannot;
1030 
1031  return CT_Can;
1032 }
1033 
1035  // C++ [expr.unary.noexcept]p3:
1036  // [Can throw] if in a potentially-evaluated context the expression would
1037  // contain:
1038  switch (E->getStmtClass()) {
1039  case Expr::CXXThrowExprClass:
1040  // - a potentially evaluated throw-expression
1041  return CT_Can;
1042 
1043  case Expr::CXXDynamicCastExprClass: {
1044  // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1045  // where T is a reference type, that requires a run-time check
1046  CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E));
1047  if (CT == CT_Can)
1048  return CT;
1049  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1050  }
1051 
1052  case Expr::CXXTypeidExprClass:
1053  // - a potentially evaluated typeid expression applied to a glvalue
1054  // expression whose type is a polymorphic class type
1055  return canTypeidThrow(*this, cast<CXXTypeidExpr>(E));
1056 
1057  // - a potentially evaluated call to a function, member function, function
1058  // pointer, or member function pointer that does not have a non-throwing
1059  // exception-specification
1060  case Expr::CallExprClass:
1061  case Expr::CXXMemberCallExprClass:
1062  case Expr::CXXOperatorCallExprClass:
1063  case Expr::UserDefinedLiteralClass: {
1064  const CallExpr *CE = cast<CallExpr>(E);
1065  CanThrowResult CT;
1066  if (E->isTypeDependent())
1067  CT = CT_Dependent;
1068  else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1069  CT = CT_Cannot;
1070  else
1071  CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
1072  if (CT == CT_Can)
1073  return CT;
1074  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1075  }
1076 
1077  case Expr::CXXConstructExprClass:
1078  case Expr::CXXTemporaryObjectExprClass: {
1079  CanThrowResult CT = canCalleeThrow(*this, E,
1080  cast<CXXConstructExpr>(E)->getConstructor());
1081  if (CT == CT_Can)
1082  return CT;
1083  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1084  }
1085 
1086  case Expr::CXXInheritedCtorInitExprClass:
1087  return canCalleeThrow(*this, E,
1088  cast<CXXInheritedCtorInitExpr>(E)->getConstructor());
1089 
1090  case Expr::LambdaExprClass: {
1091  const LambdaExpr *Lambda = cast<LambdaExpr>(E);
1094  Cap = Lambda->capture_init_begin(),
1095  CapEnd = Lambda->capture_init_end();
1096  Cap != CapEnd; ++Cap)
1097  CT = mergeCanThrow(CT, canThrow(*Cap));
1098  return CT;
1099  }
1100 
1101  case Expr::CXXNewExprClass: {
1102  CanThrowResult CT;
1103  if (E->isTypeDependent())
1104  CT = CT_Dependent;
1105  else
1106  CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew());
1107  if (CT == CT_Can)
1108  return CT;
1109  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1110  }
1111 
1112  case Expr::CXXDeleteExprClass: {
1113  CanThrowResult CT;
1114  QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType();
1115  if (DTy.isNull() || DTy->isDependentType()) {
1116  CT = CT_Dependent;
1117  } else {
1118  CT = canCalleeThrow(*this, E,
1119  cast<CXXDeleteExpr>(E)->getOperatorDelete());
1120  if (const RecordType *RT = DTy->getAs<RecordType>()) {
1121  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1122  const CXXDestructorDecl *DD = RD->getDestructor();
1123  if (DD)
1124  CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD));
1125  }
1126  if (CT == CT_Can)
1127  return CT;
1128  }
1129  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1130  }
1131 
1132  case Expr::CXXBindTemporaryExprClass: {
1133  // The bound temporary has to be destroyed again, which might throw.
1134  CanThrowResult CT = canCalleeThrow(*this, E,
1135  cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor());
1136  if (CT == CT_Can)
1137  return CT;
1138  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1139  }
1140 
1141  // ObjC message sends are like function calls, but never have exception
1142  // specs.
1143  case Expr::ObjCMessageExprClass:
1144  case Expr::ObjCPropertyRefExprClass:
1145  case Expr::ObjCSubscriptRefExprClass:
1146  return CT_Can;
1147 
1148  // All the ObjC literals that are implemented as calls are
1149  // potentially throwing unless we decide to close off that
1150  // possibility.
1151  case Expr::ObjCArrayLiteralClass:
1152  case Expr::ObjCDictionaryLiteralClass:
1153  case Expr::ObjCBoxedExprClass:
1154  return CT_Can;
1155 
1156  // Many other things have subexpressions, so we have to test those.
1157  // Some are simple:
1158  case Expr::CoawaitExprClass:
1159  case Expr::ConditionalOperatorClass:
1160  case Expr::CompoundLiteralExprClass:
1161  case Expr::CoyieldExprClass:
1162  case Expr::CXXConstCastExprClass:
1163  case Expr::CXXReinterpretCastExprClass:
1164  case Expr::CXXStdInitializerListExprClass:
1165  case Expr::DesignatedInitExprClass:
1166  case Expr::DesignatedInitUpdateExprClass:
1167  case Expr::ExprWithCleanupsClass:
1168  case Expr::ExtVectorElementExprClass:
1169  case Expr::InitListExprClass:
1170  case Expr::ArrayInitLoopExprClass:
1171  case Expr::MemberExprClass:
1172  case Expr::ObjCIsaExprClass:
1173  case Expr::ObjCIvarRefExprClass:
1174  case Expr::ParenExprClass:
1175  case Expr::ParenListExprClass:
1176  case Expr::ShuffleVectorExprClass:
1177  case Expr::ConvertVectorExprClass:
1178  case Expr::VAArgExprClass:
1179  return canSubExprsThrow(*this, E);
1180 
1181  // Some might be dependent for other reasons.
1182  case Expr::ArraySubscriptExprClass:
1183  case Expr::OMPArraySectionExprClass:
1184  case Expr::BinaryOperatorClass:
1185  case Expr::DependentCoawaitExprClass:
1186  case Expr::CompoundAssignOperatorClass:
1187  case Expr::CStyleCastExprClass:
1188  case Expr::CXXStaticCastExprClass:
1189  case Expr::CXXFunctionalCastExprClass:
1190  case Expr::ImplicitCastExprClass:
1191  case Expr::MaterializeTemporaryExprClass:
1192  case Expr::UnaryOperatorClass: {
1194  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1195  }
1196 
1197  // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1198  case Expr::StmtExprClass:
1199  return CT_Can;
1200 
1201  case Expr::CXXDefaultArgExprClass:
1202  return canThrow(cast<CXXDefaultArgExpr>(E)->getExpr());
1203 
1204  case Expr::CXXDefaultInitExprClass:
1205  return canThrow(cast<CXXDefaultInitExpr>(E)->getExpr());
1206 
1207  case Expr::ChooseExprClass:
1208  if (E->isTypeDependent() || E->isValueDependent())
1209  return CT_Dependent;
1210  return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr());
1211 
1212  case Expr::GenericSelectionExprClass:
1213  if (cast<GenericSelectionExpr>(E)->isResultDependent())
1214  return CT_Dependent;
1215  return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr());
1216 
1217  // Some expressions are always dependent.
1218  case Expr::CXXDependentScopeMemberExprClass:
1219  case Expr::CXXUnresolvedConstructExprClass:
1220  case Expr::DependentScopeDeclRefExprClass:
1221  case Expr::CXXFoldExprClass:
1222  return CT_Dependent;
1223 
1224  case Expr::AsTypeExprClass:
1225  case Expr::BinaryConditionalOperatorClass:
1226  case Expr::BlockExprClass:
1227  case Expr::CUDAKernelCallExprClass:
1228  case Expr::DeclRefExprClass:
1229  case Expr::ObjCBridgedCastExprClass:
1230  case Expr::ObjCIndirectCopyRestoreExprClass:
1231  case Expr::ObjCProtocolExprClass:
1232  case Expr::ObjCSelectorExprClass:
1233  case Expr::ObjCAvailabilityCheckExprClass:
1234  case Expr::OffsetOfExprClass:
1235  case Expr::PackExpansionExprClass:
1236  case Expr::PseudoObjectExprClass:
1237  case Expr::SubstNonTypeTemplateParmExprClass:
1238  case Expr::SubstNonTypeTemplateParmPackExprClass:
1239  case Expr::FunctionParmPackExprClass:
1240  case Expr::UnaryExprOrTypeTraitExprClass:
1241  case Expr::UnresolvedLookupExprClass:
1242  case Expr::UnresolvedMemberExprClass:
1243  case Expr::TypoExprClass:
1244  // FIXME: Can any of the above throw? If so, when?
1245  return CT_Cannot;
1246 
1247  case Expr::AddrLabelExprClass:
1248  case Expr::ArrayTypeTraitExprClass:
1249  case Expr::AtomicExprClass:
1250  case Expr::TypeTraitExprClass:
1251  case Expr::CXXBoolLiteralExprClass:
1252  case Expr::CXXNoexceptExprClass:
1253  case Expr::CXXNullPtrLiteralExprClass:
1254  case Expr::CXXPseudoDestructorExprClass:
1255  case Expr::CXXScalarValueInitExprClass:
1256  case Expr::CXXThisExprClass:
1257  case Expr::CXXUuidofExprClass:
1258  case Expr::CharacterLiteralClass:
1259  case Expr::ExpressionTraitExprClass:
1260  case Expr::FloatingLiteralClass:
1261  case Expr::GNUNullExprClass:
1262  case Expr::ImaginaryLiteralClass:
1263  case Expr::ImplicitValueInitExprClass:
1264  case Expr::IntegerLiteralClass:
1265  case Expr::ArrayInitIndexExprClass:
1266  case Expr::NoInitExprClass:
1267  case Expr::ObjCEncodeExprClass:
1268  case Expr::ObjCStringLiteralClass:
1269  case Expr::ObjCBoolLiteralExprClass:
1270  case Expr::OpaqueValueExprClass:
1271  case Expr::PredefinedExprClass:
1272  case Expr::SizeOfPackExprClass:
1273  case Expr::StringLiteralClass:
1274  // These expressions can never throw.
1275  return CT_Cannot;
1276 
1277  case Expr::MSPropertyRefExprClass:
1278  case Expr::MSPropertySubscriptExprClass:
1279  llvm_unreachable("Invalid class for expression");
1280 
1281 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:
1282 #define STMT_RANGE(Base, First, Last)
1283 #define LAST_STMT_RANGE(BASE, FIRST, LAST)
1284 #define EXPR(CLASS, PARENT)
1285 #define ABSTRACT_STMT(STMT)
1286 #include "clang/AST/StmtNodes.inc"
1287  case Expr::NoStmtClass:
1288  llvm_unreachable("Invalid class for expression");
1289  }
1290  llvm_unreachable("Bogus StmtClass");
1291 }
1292 
1293 } // end namespace clang
CanThrowResult canThrow(const Expr *E)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1631
no exception specification
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2222
A (possibly-)qualified type.
Definition: Type.h:614
bool isArrayType() const
Definition: Type.h:5805
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
unsigned getNumExceptions() const
Definition: Type.h:3456
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2753
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Stmt - This represents one statement.
Definition: Stmt.h:60
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:435
Defines the SourceManager interface.
bool isRecordType() const
Definition: Type.h:5823
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:5950
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc)
CheckParamExceptionSpec - Check if the parameter and return types of the two functions have equivalen...
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:377
void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Evaluate the implicit exception specification for a defaulted special member function.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:474
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
A container of type source information.
Definition: Decl.h:62
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
Definition: ExprCXX.h:1646
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
The noexcept specifier has a bad expression.
Definition: Type.h:3449
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1734
unsigned getNumParams() const
Definition: Type.h:3393
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6099
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2130
void clear()
Clear the base-paths results.
Expr * getExprOperand() const
Definition: ExprCXX.h:645
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:847
Defines the clang::Expr interface and subclasses for C++ expressions.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3398
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
NoexceptResult
Result type of getNoexceptSpec().
Definition: Type.h:3447
bool isReferenceType() const
Definition: Type.h:5775
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1886
Expr * getSubExpr()
Definition: Expr.h:2762
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2669
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:590
Microsoft throw(...) extension.
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec...
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1660
child_range children()
Definition: Stmt.cpp:208
static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc)
Defines the Diagnostic-related interfaces.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, const ASTContext *Context=nullptr) const
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.h:3492
static bool CheckEquivalentExceptionSpecImpl(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification=nullptr, bool *MissingEmptyExceptionSpecification=nullptr, bool AllowNoexceptAllMatchWithNoSpec=false, bool IsOperatorNew=false)
CheckEquivalentExceptionSpec - Check if the two types have compatible exception specifications.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1519
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1437
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2115
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:2912
bool hasAttr() const
Definition: DeclBase.h:521
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1569
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn&#39;t been determined yet (either because...
Definition: Type.h:3471
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3170
CanThrowResult mergeCanThrow(CanThrowResult CT1, CanThrowResult CT2)
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3020
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:593
Expr - This represents one expression.
Definition: Expr.h:106
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
const FunctionProtoType * T
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6162
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2566
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:112
const Expr * getCallee() const
Definition: Expr.h:2249
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &O)
Definition: Type.h:3298
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7350
Defines the clang::TypeLoc interface and its subclasses.
There is no noexcept specifier.
Definition: Type.h:3448
QualType getType() const
Definition: Expr.h:128
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1295
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:681
static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC)
RecordDecl * getDecl() const
Definition: Type.h:3848
CanThrowResult
Possible results from evaluation of a noexcept expression.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:305
Kind
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3275
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1158
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3402
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:289
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3106
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
CastKind getCastKind() const
Definition: Expr.h:2758
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1918
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3430
static bool hasImplicitExceptionSpec(FunctionDecl *Decl)
Determine whether a function has an implicitly-generated exception specification. ...
The noexcept specifier evaluates to true.
Definition: Type.h:3452
static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC)
Expr * getNoexceptExpr() const
Definition: Type.h:3461
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)
Determine if we&#39;re in a case where we need to (incorrectly) eagerly parse an exception specification ...
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3426
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
exception_iterator exception_begin() const
Definition: Type.h:3535
StringRef getName() const
Return the actual identifier string.
bool isTypeOperand() const
Definition: ExprCXX.h:628
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
not evaluated yet, for special member function
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:390
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:2780
StmtClass getStmtClass() const
Definition: Stmt.h:361
ArrayRef< QualType > exceptions() const
Definition: Type.h:3532
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2033
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i...
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2440
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2550
Decl * getCalleeDecl()
Definition: Expr.cpp:1220
Pointer to a block type.
Definition: Type.h:2325
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3839
bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc)
CheckExceptionSpecSubset - Check whether the second function type&#39;s exception specification is a subs...
bool isFunctionType() const
Definition: Type.h:5763
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:674
CXXBasePath & front()
The noexcept specifier evaluates to false.
Definition: Type.h:3451
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2358
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
SourceManager & getSourceManager()
Definition: ASTContext.h:618
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2124
QualType getParamType(unsigned i) const
Definition: Type.h:3394
Represents a C++ struct/union/class.
Definition: DeclCXX.h:266
bool isVoidType() const
Definition: Type.h:5963
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2822
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
bool isPRValue() const
Definition: Expr.h:355
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D)
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1795
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1672
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
QualType getType() const
Definition: Decl.h:602
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2802
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:316
static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E)
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:610
The noexcept specifier is dependent.
Definition: Type.h:3450
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
void setType(QualType newType)
Definition: Decl.h:603
SourceLocation getBegin() const
static const FunctionProtoType * GetUnderlyingFunction(QualType T)
SourceLocation getLocation() const
Definition: DeclBase.h:407
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:3001
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2432