clang  3.7.0
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.
47  if (!RD || RD->getEnclosingNamespaceContext() != getStdNamespace() ||
48  !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
49  !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
50  return false;
51 
52  // Only apply this hack within a system header.
54  return false;
55 
56  return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
57  .Case("array", true)
58  .Case("pair", true)
59  .Case("priority_queue", true)
60  .Case("stack", true)
61  .Case("queue", true)
62  .Default(false);
63 }
64 
65 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
66 /// exception specification. Incomplete types, or pointers to incomplete types
67 /// other than void are not allowed.
68 ///
69 /// \param[in,out] T The exception type. This will be decayed to a pointer type
70 /// when the input is an array or a function type.
72  // C++11 [except.spec]p2:
73  // A type cv T, "array of T", or "function returning T" denoted
74  // in an exception-specification is adjusted to type T, "pointer to T", or
75  // "pointer to function returning T", respectively.
76  //
77  // We also apply this rule in C++98.
78  if (T->isArrayType())
80  else if (T->isFunctionType())
81  T = Context.getPointerType(T);
82 
83  int Kind = 0;
84  QualType PointeeT = T;
85  if (const PointerType *PT = T->getAs<PointerType>()) {
86  PointeeT = PT->getPointeeType();
87  Kind = 1;
88 
89  // cv void* is explicitly permitted, despite being a pointer to an
90  // incomplete type.
91  if (PointeeT->isVoidType())
92  return false;
93  } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
94  PointeeT = RT->getPointeeType();
95  Kind = 2;
96 
97  if (RT->isRValueReferenceType()) {
98  // C++11 [except.spec]p2:
99  // A type denoted in an exception-specification shall not denote [...]
100  // an rvalue reference type.
101  Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
102  << T << Range;
103  return true;
104  }
105  }
106 
107  // C++11 [except.spec]p2:
108  // A type denoted in an exception-specification shall not denote an
109  // incomplete type other than a class currently being defined [...].
110  // A type denoted in an exception-specification shall not denote a
111  // pointer or reference to an incomplete type, other than (cv) void* or a
112  // pointer or reference to a class currently being defined.
113  if (!(PointeeT->isRecordType() &&
114  PointeeT->getAs<RecordType>()->isBeingDefined()) &&
115  RequireCompleteType(Range.getBegin(), PointeeT,
116  diag::err_incomplete_in_exception_spec, Kind, Range))
117  return true;
118 
119  return false;
120 }
121 
122 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
123 /// to member to a function with an exception specification. This means that
124 /// it is invalid to add another level of indirection.
126  if (const PointerType *PT = T->getAs<PointerType>())
127  T = PT->getPointeeType();
128  else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
129  T = PT->getPointeeType();
130  else
131  return false;
132 
133  const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
134  if (!FnT)
135  return false;
136 
137  return FnT->hasExceptionSpec();
138 }
139 
140 const FunctionProtoType *
142  if (FPT->getExceptionSpecType() == EST_Unparsed) {
143  Diag(Loc, diag::err_exception_spec_not_parsed);
144  return nullptr;
145  }
146 
148  return FPT;
149 
150  FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
151  const FunctionProtoType *SourceFPT =
152  SourceDecl->getType()->castAs<FunctionProtoType>();
153 
154  // If the exception specification has already been resolved, just return it.
156  return SourceFPT;
157 
158  // Compute or instantiate the exception specification now.
159  if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
160  EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl));
161  else
162  InstantiateExceptionSpec(Loc, SourceDecl);
163 
164  const FunctionProtoType *Proto =
165  SourceDecl->getType()->castAs<FunctionProtoType>();
166  if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
167  Diag(Loc, diag::err_exception_spec_not_parsed);
168  Proto = nullptr;
169  }
170  return Proto;
171 }
172 
173 void
176  // If we've fully resolved the exception specification, notify listeners.
178  if (auto *Listener = getASTMutationListener())
179  Listener->ResolvedExceptionSpec(FD);
180 
181  for (auto *Redecl : FD->redecls())
182  Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
183 }
184 
185 /// Determine whether a function has an implicitly-generated exception
186 /// specification.
188  if (!isa<CXXDestructorDecl>(Decl) &&
189  Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
190  Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
191  return false;
192 
193  // For a function that the user didn't declare:
194  // - if this is a destructor, its exception specification is implicit.
195  // - if this is 'operator delete' or 'operator delete[]', the exception
196  // specification is as-if an explicit exception specification was given
197  // (per [basic.stc.dynamic]p2).
198  if (!Decl->getTypeSourceInfo())
199  return isa<CXXDestructorDecl>(Decl);
200 
201  const FunctionProtoType *Ty =
203  return !Ty->hasExceptionSpec();
204 }
205 
208  bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
209  bool MissingExceptionSpecification = false;
210  bool MissingEmptyExceptionSpecification = false;
211 
212  unsigned DiagID = diag::err_mismatched_exception_spec;
213  bool ReturnValueOnError = true;
214  if (getLangOpts().MicrosoftExt) {
215  DiagID = diag::ext_mismatched_exception_spec;
216  ReturnValueOnError = false;
217  }
218 
219  // Check the types as written: they must match before any exception
220  // specification adjustment is applied.
222  PDiag(DiagID), PDiag(diag::note_previous_declaration),
223  Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
224  New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
225  &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
226  /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
227  // C++11 [except.spec]p4 [DR1492]:
228  // If a declaration of a function has an implicit
229  // exception-specification, other declarations of the function shall
230  // not specify an exception-specification.
231  if (getLangOpts().CPlusPlus11 &&
233  Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
234  << hasImplicitExceptionSpec(Old);
235  if (!Old->getLocation().isInvalid())
236  Diag(Old->getLocation(), diag::note_previous_declaration);
237  }
238  return false;
239  }
240 
241  // The failure was something other than an missing exception
242  // specification; return an error, except in MS mode where this is a warning.
243  if (!MissingExceptionSpecification)
244  return ReturnValueOnError;
245 
246  const FunctionProtoType *NewProto =
247  New->getType()->castAs<FunctionProtoType>();
248 
249  // The new function declaration is only missing an empty exception
250  // specification "throw()". If the throw() specification came from a
251  // function in a system header that has C linkage, just add an empty
252  // exception specification to the "new" declaration. This is an
253  // egregious workaround for glibc, which adds throw() specifications
254  // to many libc functions as an optimization. Unfortunately, that
255  // optimization isn't permitted by the C++ standard, so we're forced
256  // to work around it here.
257  if (MissingEmptyExceptionSpecification && NewProto &&
258  (Old->getLocation().isInvalid() ||
260  Old->isExternC()) {
262  NewProto->getReturnType(), NewProto->getParamTypes(),
264  return false;
265  }
266 
267  const FunctionProtoType *OldProto =
268  Old->getType()->castAs<FunctionProtoType>();
269 
271  if (ESI.Type == EST_Dynamic) {
272  ESI.Exceptions = OldProto->exceptions();
273  } else if (ESI.Type == EST_ComputedNoexcept) {
274  // FIXME: We can't just take the expression from the old prototype. It
275  // likely contains references to the old prototype's parameters.
276  }
277 
278  // Update the type of the function with the appropriate exception
279  // specification.
281  NewProto->getReturnType(), NewProto->getParamTypes(),
282  NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
283 
284  // Warn about the lack of exception specification.
285  SmallString<128> ExceptionSpecString;
286  llvm::raw_svector_ostream OS(ExceptionSpecString);
287  switch (OldProto->getExceptionSpecType()) {
288  case EST_DynamicNone:
289  OS << "throw()";
290  break;
291 
292  case EST_Dynamic: {
293  OS << "throw(";
294  bool OnFirstException = true;
295  for (const auto &E : OldProto->exceptions()) {
296  if (OnFirstException)
297  OnFirstException = false;
298  else
299  OS << ", ";
300 
301  OS << E.getAsString(getPrintingPolicy());
302  }
303  OS << ")";
304  break;
305  }
306 
307  case EST_BasicNoexcept:
308  OS << "noexcept";
309  break;
310 
312  OS << "noexcept(";
313  assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
314  OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
315  OS << ")";
316  break;
317 
318  default:
319  llvm_unreachable("This spec type is compatible with none.");
320  }
321  OS.flush();
322 
323  SourceLocation FixItLoc;
324  if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
325  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
326  if (FunctionTypeLoc FTLoc = TL.getAs<FunctionTypeLoc>())
327  FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
328  }
329 
330  if (FixItLoc.isInvalid())
331  Diag(New->getLocation(), diag::warn_missing_exception_specification)
332  << New << OS.str();
333  else {
334  // FIXME: This will get more complicated with C++0x
335  // late-specified return types.
336  Diag(New->getLocation(), diag::warn_missing_exception_specification)
337  << New << OS.str()
338  << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
339  }
340 
341  if (!Old->getLocation().isInvalid())
342  Diag(Old->getLocation(), diag::note_previous_declaration);
343 
344  return false;
345 }
346 
347 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
348 /// exception specifications. Exception specifications are equivalent if
349 /// they allow exactly the same set of exception types. It does not matter how
350 /// that is achieved. See C++ [except.spec]p2.
352  const FunctionProtoType *Old, SourceLocation OldLoc,
353  const FunctionProtoType *New, SourceLocation NewLoc) {
354  unsigned DiagID = diag::err_mismatched_exception_spec;
355  if (getLangOpts().MicrosoftExt)
356  DiagID = diag::ext_mismatched_exception_spec;
358  PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc);
359 
360  // In Microsoft mode, mismatching exception specifications just cause a warning.
361  if (getLangOpts().MicrosoftExt)
362  return false;
363  return Result;
364 }
365 
366 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
367 /// exception specifications. See C++ [except.spec]p3.
368 ///
369 /// \return \c false if the exception specifications match, \c true if there is
370 /// a problem. If \c true is returned, either a diagnostic has already been
371 /// produced or \c *MissingExceptionSpecification is set to \c true.
373  const PartialDiagnostic & NoteID,
374  const FunctionProtoType *Old,
375  SourceLocation OldLoc,
376  const FunctionProtoType *New,
377  SourceLocation NewLoc,
378  bool *MissingExceptionSpecification,
379  bool*MissingEmptyExceptionSpecification,
380  bool AllowNoexceptAllMatchWithNoSpec,
381  bool IsOperatorNew) {
382  // Just completely ignore this under -fno-exceptions.
383  if (!getLangOpts().CXXExceptions)
384  return false;
385 
386  if (MissingExceptionSpecification)
387  *MissingExceptionSpecification = false;
388 
389  if (MissingEmptyExceptionSpecification)
390  *MissingEmptyExceptionSpecification = false;
391 
392  Old = ResolveExceptionSpec(NewLoc, Old);
393  if (!Old)
394  return false;
395  New = ResolveExceptionSpec(NewLoc, New);
396  if (!New)
397  return false;
398 
399  // C++0x [except.spec]p3: Two exception-specifications are compatible if:
400  // - both are non-throwing, regardless of their form,
401  // - both have the form noexcept(constant-expression) and the constant-
402  // expressions are equivalent,
403  // - both are dynamic-exception-specifications that have the same set of
404  // adjusted types.
405  //
406  // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
407  // of the form throw(), noexcept, or noexcept(constant-expression) where the
408  // constant-expression yields true.
409  //
410  // C++0x [except.spec]p4: If any declaration of a function has an exception-
411  // specifier that is not a noexcept-specification allowing all exceptions,
412  // all declarations [...] of that function shall have a compatible
413  // exception-specification.
414  //
415  // That last point basically means that noexcept(false) matches no spec.
416  // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
417 
420 
421  assert(!isUnresolvedExceptionSpec(OldEST) &&
422  !isUnresolvedExceptionSpec(NewEST) &&
423  "Shouldn't see unknown exception specifications here");
424 
425  // Shortcut the case where both have no spec.
426  if (OldEST == EST_None && NewEST == EST_None)
427  return false;
428 
431  if (OldNR == FunctionProtoType::NR_BadNoexcept ||
433  return false;
434 
435  // Dependent noexcept specifiers are compatible with each other, but nothing
436  // else.
437  // One noexcept is compatible with another if the argument is the same
438  if (OldNR == NewNR &&
441  return false;
442  if (OldNR != NewNR &&
445  Diag(NewLoc, DiagID);
446  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
447  Diag(OldLoc, NoteID);
448  return true;
449  }
450 
451  // The MS extension throw(...) is compatible with itself.
452  if (OldEST == EST_MSAny && NewEST == EST_MSAny)
453  return false;
454 
455  // It's also compatible with no spec.
456  if ((OldEST == EST_None && NewEST == EST_MSAny) ||
457  (OldEST == EST_MSAny && NewEST == EST_None))
458  return false;
459 
460  // It's also compatible with noexcept(false).
461  if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw)
462  return false;
463  if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw)
464  return false;
465 
466  // As described above, noexcept(false) matches no spec only for functions.
467  if (AllowNoexceptAllMatchWithNoSpec) {
468  if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw)
469  return false;
470  if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw)
471  return false;
472  }
473 
474  // Any non-throwing specifications are compatible.
475  bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow ||
476  OldEST == EST_DynamicNone;
477  bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow ||
478  NewEST == EST_DynamicNone;
479  if (OldNonThrowing && NewNonThrowing)
480  return false;
481 
482  // As a special compatibility feature, under C++0x we accept no spec and
483  // throw(std::bad_alloc) as equivalent for operator new and operator new[].
484  // This is because the implicit declaration changed, but old code would break.
485  if (getLangOpts().CPlusPlus11 && IsOperatorNew) {
486  const FunctionProtoType *WithExceptions = nullptr;
487  if (OldEST == EST_None && NewEST == EST_Dynamic)
488  WithExceptions = New;
489  else if (OldEST == EST_Dynamic && NewEST == EST_None)
490  WithExceptions = Old;
491  if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
492  // One has no spec, the other throw(something). If that something is
493  // std::bad_alloc, all conditions are met.
494  QualType Exception = *WithExceptions->exception_begin();
495  if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
496  IdentifierInfo* Name = ExRecord->getIdentifier();
497  if (Name && Name->getName() == "bad_alloc") {
498  // It's called bad_alloc, but is it in std?
499  if (ExRecord->isInStdNamespace()) {
500  return false;
501  }
502  }
503  }
504  }
505  }
506 
507  // At this point, the only remaining valid case is two matching dynamic
508  // specifications. We return here unless both specifications are dynamic.
509  if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) {
510  if (MissingExceptionSpecification && Old->hasExceptionSpec() &&
511  !New->hasExceptionSpec()) {
512  // The old type has an exception specification of some sort, but
513  // the new type does not.
514  *MissingExceptionSpecification = true;
515 
516  if (MissingEmptyExceptionSpecification && OldNonThrowing) {
517  // The old type has a throw() or noexcept(true) exception specification
518  // and the new type has no exception specification, and the caller asked
519  // to handle this itself.
520  *MissingEmptyExceptionSpecification = true;
521  }
522 
523  return true;
524  }
525 
526  Diag(NewLoc, DiagID);
527  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
528  Diag(OldLoc, NoteID);
529  return true;
530  }
531 
532  assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic &&
533  "Exception compatibility logic error: non-dynamic spec slipped through.");
534 
535  bool Success = true;
536  // Both have a dynamic exception spec. Collect the first set, then compare
537  // to the second.
538  llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
539  for (const auto &I : Old->exceptions())
540  OldTypes.insert(Context.getCanonicalType(I).getUnqualifiedType());
541 
542  for (const auto &I : New->exceptions()) {
544  if(OldTypes.count(TypePtr))
545  NewTypes.insert(TypePtr);
546  else
547  Success = false;
548  }
549 
550  Success = Success && OldTypes.size() == NewTypes.size();
551 
552  if (Success) {
553  return false;
554  }
555  Diag(NewLoc, DiagID);
556  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
557  Diag(OldLoc, NoteID);
558  return true;
559 }
560 
561 /// CheckExceptionSpecSubset - Check whether the second function type's
562 /// exception specification is a subset (or equivalent) of the first function
563 /// type. This is used by override and pointer assignment checks.
565  const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
566  const FunctionProtoType *Superset, SourceLocation SuperLoc,
567  const FunctionProtoType *Subset, SourceLocation SubLoc) {
568 
569  // Just auto-succeed under -fno-exceptions.
570  if (!getLangOpts().CXXExceptions)
571  return false;
572 
573  // FIXME: As usual, we could be more specific in our error messages, but
574  // that better waits until we've got types with source locations.
575 
576  if (!SubLoc.isValid())
577  SubLoc = SuperLoc;
578 
579  // Resolve the exception specifications, if needed.
580  Superset = ResolveExceptionSpec(SuperLoc, Superset);
581  if (!Superset)
582  return false;
583  Subset = ResolveExceptionSpec(SubLoc, Subset);
584  if (!Subset)
585  return false;
586 
587  ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
588 
589  // If superset contains everything, we're done.
590  if (SuperEST == EST_None || SuperEST == EST_MSAny)
591  return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
592 
593  // If there are dependent noexcept specs, assume everything is fine. Unlike
594  // with the equivalency check, this is safe in this case, because we don't
595  // want to merge declarations. Checks after instantiation will catch any
596  // omissions we make here.
597  // We also shortcut checking if a noexcept expression was bad.
598 
600  if (SuperNR == FunctionProtoType::NR_BadNoexcept ||
602  return false;
603 
604  // Another case of the superset containing everything.
605  if (SuperNR == FunctionProtoType::NR_Throw)
606  return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
607 
609 
610  assert(!isUnresolvedExceptionSpec(SuperEST) &&
611  !isUnresolvedExceptionSpec(SubEST) &&
612  "Shouldn't see unknown exception specifications here");
613 
614  // It does not. If the subset contains everything, we've failed.
615  if (SubEST == EST_None || SubEST == EST_MSAny) {
616  Diag(SubLoc, DiagID);
617  if (NoteID.getDiagID() != 0)
618  Diag(SuperLoc, NoteID);
619  return true;
620  }
621 
623  if (SubNR == FunctionProtoType::NR_BadNoexcept ||
625  return false;
626 
627  // Another case of the subset containing everything.
628  if (SubNR == FunctionProtoType::NR_Throw) {
629  Diag(SubLoc, DiagID);
630  if (NoteID.getDiagID() != 0)
631  Diag(SuperLoc, NoteID);
632  return true;
633  }
634 
635  // If the subset contains nothing, we're done.
636  if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow)
637  return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
638 
639  // Otherwise, if the superset contains nothing, we've failed.
640  if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) {
641  Diag(SubLoc, DiagID);
642  if (NoteID.getDiagID() != 0)
643  Diag(SuperLoc, NoteID);
644  return true;
645  }
646 
647  assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
648  "Exception spec subset: non-dynamic case slipped through.");
649 
650  // Neither contains everything or nothing. Do a proper comparison.
651  for (const auto &SubI : Subset->exceptions()) {
652  // Take one type from the subset.
653  QualType CanonicalSubT = Context.getCanonicalType(SubI);
654  // Unwrap pointers and references so that we can do checks within a class
655  // hierarchy. Don't unwrap member pointers; they don't have hierarchy
656  // conversions on the pointee.
657  bool SubIsPointer = false;
658  if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>())
659  CanonicalSubT = RefTy->getPointeeType();
660  if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) {
661  CanonicalSubT = PtrTy->getPointeeType();
662  SubIsPointer = true;
663  }
664  bool SubIsClass = CanonicalSubT->isRecordType();
665  CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType();
666 
667  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
668  /*DetectVirtual=*/false);
669 
670  bool Contained = false;
671  // Make sure it's in the superset.
672  for (const auto &SuperI : Superset->exceptions()) {
673  QualType CanonicalSuperT = Context.getCanonicalType(SuperI);
674  // SubT must be SuperT or derived from it, or pointer or reference to
675  // such types.
676  if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>())
677  CanonicalSuperT = RefTy->getPointeeType();
678  if (SubIsPointer) {
679  if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>())
680  CanonicalSuperT = PtrTy->getPointeeType();
681  else {
682  continue;
683  }
684  }
685  CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType();
686  // If the types are the same, move on to the next type in the subset.
687  if (CanonicalSubT == CanonicalSuperT) {
688  Contained = true;
689  break;
690  }
691 
692  // Otherwise we need to check the inheritance.
693  if (!SubIsClass || !CanonicalSuperT->isRecordType())
694  continue;
695 
696  Paths.clear();
697  if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths))
698  continue;
699 
700  if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT)))
701  continue;
702 
703  // Do this check from a context without privileges.
705  CanonicalSuperT, CanonicalSubT,
706  Paths.front(),
707  /*Diagnostic*/ 0,
708  /*ForceCheck*/ true,
709  /*ForceUnprivileged*/ true)) {
710  case AR_accessible: break;
711  case AR_inaccessible: continue;
712  case AR_dependent:
713  llvm_unreachable("access check dependent for unprivileged context");
714  case AR_delayed:
715  llvm_unreachable("access check delayed in non-declaration");
716  }
717 
718  Contained = true;
719  break;
720  }
721  if (!Contained) {
722  Diag(SubLoc, DiagID);
723  if (NoteID.getDiagID() != 0)
724  Diag(SuperLoc, NoteID);
725  return true;
726  }
727  }
728  // We've run half the gauntlet.
729  return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
730 }
731 
733  const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
734  QualType Target, SourceLocation TargetLoc,
735  QualType Source, SourceLocation SourceLoc)
736 {
737  const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
738  if (!TFunc)
739  return false;
740  const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
741  if (!SFunc)
742  return false;
743 
744  return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
745  SFunc, SourceLoc);
746 }
747 
748 /// CheckParamExceptionSpec - Check if the parameter and return types of the
749 /// two functions have equivalent exception specs. This is part of the
750 /// assignment and override compatibility check. We do not check the parameters
751 /// of parameter function pointers recursively, as no sane programmer would
752 /// even be able to write such a function type.
754  const FunctionProtoType *Target,
755  SourceLocation TargetLoc,
756  const FunctionProtoType *Source,
757  SourceLocation SourceLoc) {
759  *this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(),
760  Target->getReturnType(), TargetLoc, Source->getReturnType(),
761  SourceLoc))
762  return true;
763 
764  // We shouldn't even be testing this unless the arguments are otherwise
765  // compatible.
766  assert(Target->getNumParams() == Source->getNumParams() &&
767  "Functions have different argument counts.");
768  for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
770  *this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(),
771  Target->getParamType(i), TargetLoc, Source->getParamType(i),
772  SourceLoc))
773  return true;
774  }
775  return false;
776 }
777 
779  // First we check for applicability.
780  // Target type must be a function, function pointer or function reference.
781  const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
782  if (!ToFunc || ToFunc->hasDependentExceptionSpec())
783  return false;
784 
785  // SourceType must be a function or function pointer.
786  const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
787  if (!FromFunc || FromFunc->hasDependentExceptionSpec())
788  return false;
789 
790  // Now we've got the correct types on both sides, check their compatibility.
791  // This means that the source of the conversion can only throw a subset of
792  // the exceptions of the target, and any exception specs on arguments or
793  // return types must be equivalent.
794  //
795  // FIXME: If there is a nested dependent exception specification, we should
796  // not be checking it here. This is fine:
797  // template<typename T> void f() {
798  // void (*p)(void (*) throw(T));
799  // void (*q)(void (*) throw(int)) = p;
800  // }
801  // ... because it might be instantiated with T=int.
802  return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs),
803  PDiag(), ToFunc,
804  From->getSourceRange().getBegin(),
805  FromFunc, SourceLocation());
806 }
807 
809  const CXXMethodDecl *Old) {
810  // If the new exception specification hasn't been parsed yet, skip the check.
811  // We'll get called again once it's been parsed.
812  if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
813  EST_Unparsed)
814  return false;
815  if (getLangOpts().CPlusPlus11 && isa<CXXDestructorDecl>(New)) {
816  // Don't check uninstantiated template destructors at all. We can only
817  // synthesize correct specs after the template is instantiated.
818  if (New->getParent()->isDependentType())
819  return false;
820  if (New->getParent()->isBeingDefined()) {
821  // The destructor might be updated once the definition is finished. So
822  // remember it and check later.
823  DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
824  return false;
825  }
826  }
827  // If the old exception specification hasn't been parsed yet, remember that
828  // we need to perform this check when we get to the end of the outermost
829  // lexically-surrounding class.
830  if (Old->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
831  EST_Unparsed) {
832  DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
833  return false;
834  }
835  unsigned DiagID = diag::err_override_exception_spec;
836  if (getLangOpts().MicrosoftExt)
837  DiagID = diag::ext_override_exception_spec;
838  return CheckExceptionSpecSubset(PDiag(DiagID),
839  PDiag(diag::note_overridden_virtual_function),
840  Old->getType()->getAs<FunctionProtoType>(),
841  Old->getLocation(),
842  New->getType()->getAs<FunctionProtoType>(),
843  New->getLocation());
844 }
845 
848  for (const Stmt *SubStmt : E->children()) {
849  R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
850  if (R == CT_Can)
851  break;
852  }
853  return R;
854 }
855 
856 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
857  assert(D && "Expected decl");
858 
859  // See if we can get a function type from the decl somehow.
860  const ValueDecl *VD = dyn_cast<ValueDecl>(D);
861  if (!VD) // If we have no clue what we're calling, assume the worst.
862  return CT_Can;
863 
864  // As an extension, we assume that __attribute__((nothrow)) functions don't
865  // throw.
866  if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
867  return CT_Cannot;
868 
869  QualType T = VD->getType();
870  const FunctionProtoType *FT;
871  if ((FT = T->getAs<FunctionProtoType>())) {
872  } else if (const PointerType *PT = T->getAs<PointerType>())
873  FT = PT->getPointeeType()->getAs<FunctionProtoType>();
874  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
875  FT = RT->getPointeeType()->getAs<FunctionProtoType>();
876  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
877  FT = MT->getPointeeType()->getAs<FunctionProtoType>();
878  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
879  FT = BT->getPointeeType()->getAs<FunctionProtoType>();
880 
881  if (!FT)
882  return CT_Can;
883 
884  FT = S.ResolveExceptionSpec(E->getLocStart(), FT);
885  if (!FT)
886  return CT_Can;
887 
888  return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
889 }
890 
892  if (DC->isTypeDependent())
893  return CT_Dependent;
894 
895  if (!DC->getTypeAsWritten()->isReferenceType())
896  return CT_Cannot;
897 
898  if (DC->getSubExpr()->isTypeDependent())
899  return CT_Dependent;
900 
901  return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
902 }
903 
905  if (DC->isTypeOperand())
906  return CT_Cannot;
907 
908  Expr *Op = DC->getExprOperand();
909  if (Op->isTypeDependent())
910  return CT_Dependent;
911 
912  const RecordType *RT = Op->getType()->getAs<RecordType>();
913  if (!RT)
914  return CT_Cannot;
915 
916  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
917  return CT_Cannot;
918 
919  if (Op->Classify(S.Context).isPRValue())
920  return CT_Cannot;
921 
922  return CT_Can;
923 }
924 
926  // C++ [expr.unary.noexcept]p3:
927  // [Can throw] if in a potentially-evaluated context the expression would
928  // contain:
929  switch (E->getStmtClass()) {
930  case Expr::CXXThrowExprClass:
931  // - a potentially evaluated throw-expression
932  return CT_Can;
933 
934  case Expr::CXXDynamicCastExprClass: {
935  // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
936  // where T is a reference type, that requires a run-time check
937  CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E));
938  if (CT == CT_Can)
939  return CT;
940  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
941  }
942 
943  case Expr::CXXTypeidExprClass:
944  // - a potentially evaluated typeid expression applied to a glvalue
945  // expression whose type is a polymorphic class type
946  return canTypeidThrow(*this, cast<CXXTypeidExpr>(E));
947 
948  // - a potentially evaluated call to a function, member function, function
949  // pointer, or member function pointer that does not have a non-throwing
950  // exception-specification
951  case Expr::CallExprClass:
952  case Expr::CXXMemberCallExprClass:
953  case Expr::CXXOperatorCallExprClass:
954  case Expr::UserDefinedLiteralClass: {
955  const CallExpr *CE = cast<CallExpr>(E);
956  CanThrowResult CT;
957  if (E->isTypeDependent())
958  CT = CT_Dependent;
959  else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
960  CT = CT_Cannot;
961  else if (CE->getCalleeDecl())
962  CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
963  else
964  CT = CT_Can;
965  if (CT == CT_Can)
966  return CT;
967  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
968  }
969 
970  case Expr::CXXConstructExprClass:
971  case Expr::CXXTemporaryObjectExprClass: {
972  CanThrowResult CT = canCalleeThrow(*this, E,
973  cast<CXXConstructExpr>(E)->getConstructor());
974  if (CT == CT_Can)
975  return CT;
976  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
977  }
978 
979  case Expr::LambdaExprClass: {
980  const LambdaExpr *Lambda = cast<LambdaExpr>(E);
983  CapEnd = Lambda->capture_init_end();
984  Cap != CapEnd; ++Cap)
985  CT = mergeCanThrow(CT, canThrow(*Cap));
986  return CT;
987  }
988 
989  case Expr::CXXNewExprClass: {
990  CanThrowResult CT;
991  if (E->isTypeDependent())
992  CT = CT_Dependent;
993  else
994  CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew());
995  if (CT == CT_Can)
996  return CT;
997  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
998  }
999 
1000  case Expr::CXXDeleteExprClass: {
1001  CanThrowResult CT;
1002  QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType();
1003  if (DTy.isNull() || DTy->isDependentType()) {
1004  CT = CT_Dependent;
1005  } else {
1006  CT = canCalleeThrow(*this, E,
1007  cast<CXXDeleteExpr>(E)->getOperatorDelete());
1008  if (const RecordType *RT = DTy->getAs<RecordType>()) {
1009  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1010  const CXXDestructorDecl *DD = RD->getDestructor();
1011  if (DD)
1012  CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD));
1013  }
1014  if (CT == CT_Can)
1015  return CT;
1016  }
1017  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1018  }
1019 
1020  case Expr::CXXBindTemporaryExprClass: {
1021  // The bound temporary has to be destroyed again, which might throw.
1022  CanThrowResult CT = canCalleeThrow(*this, E,
1023  cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor());
1024  if (CT == CT_Can)
1025  return CT;
1026  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1027  }
1028 
1029  // ObjC message sends are like function calls, but never have exception
1030  // specs.
1031  case Expr::ObjCMessageExprClass:
1032  case Expr::ObjCPropertyRefExprClass:
1033  case Expr::ObjCSubscriptRefExprClass:
1034  return CT_Can;
1035 
1036  // All the ObjC literals that are implemented as calls are
1037  // potentially throwing unless we decide to close off that
1038  // possibility.
1039  case Expr::ObjCArrayLiteralClass:
1040  case Expr::ObjCDictionaryLiteralClass:
1041  case Expr::ObjCBoxedExprClass:
1042  return CT_Can;
1043 
1044  // Many other things have subexpressions, so we have to test those.
1045  // Some are simple:
1046  case Expr::ConditionalOperatorClass:
1047  case Expr::CompoundLiteralExprClass:
1048  case Expr::CXXConstCastExprClass:
1049  case Expr::CXXReinterpretCastExprClass:
1050  case Expr::CXXStdInitializerListExprClass:
1051  case Expr::DesignatedInitExprClass:
1052  case Expr::DesignatedInitUpdateExprClass:
1053  case Expr::ExprWithCleanupsClass:
1054  case Expr::ExtVectorElementExprClass:
1055  case Expr::InitListExprClass:
1056  case Expr::MemberExprClass:
1057  case Expr::ObjCIsaExprClass:
1058  case Expr::ObjCIvarRefExprClass:
1059  case Expr::ParenExprClass:
1060  case Expr::ParenListExprClass:
1061  case Expr::ShuffleVectorExprClass:
1062  case Expr::ConvertVectorExprClass:
1063  case Expr::VAArgExprClass:
1064  return canSubExprsThrow(*this, E);
1065 
1066  // Some might be dependent for other reasons.
1067  case Expr::ArraySubscriptExprClass:
1068  case Expr::BinaryOperatorClass:
1069  case Expr::CompoundAssignOperatorClass:
1070  case Expr::CStyleCastExprClass:
1071  case Expr::CXXStaticCastExprClass:
1072  case Expr::CXXFunctionalCastExprClass:
1073  case Expr::ImplicitCastExprClass:
1074  case Expr::MaterializeTemporaryExprClass:
1075  case Expr::UnaryOperatorClass: {
1077  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1078  }
1079 
1080  // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1081  case Expr::StmtExprClass:
1082  return CT_Can;
1083 
1084  case Expr::CXXDefaultArgExprClass:
1085  return canThrow(cast<CXXDefaultArgExpr>(E)->getExpr());
1086 
1087  case Expr::CXXDefaultInitExprClass:
1088  return canThrow(cast<CXXDefaultInitExpr>(E)->getExpr());
1089 
1090  case Expr::ChooseExprClass:
1091  if (E->isTypeDependent() || E->isValueDependent())
1092  return CT_Dependent;
1093  return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr());
1094 
1095  case Expr::GenericSelectionExprClass:
1096  if (cast<GenericSelectionExpr>(E)->isResultDependent())
1097  return CT_Dependent;
1098  return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr());
1099 
1100  // Some expressions are always dependent.
1101  case Expr::CXXDependentScopeMemberExprClass:
1102  case Expr::CXXUnresolvedConstructExprClass:
1103  case Expr::DependentScopeDeclRefExprClass:
1104  case Expr::CXXFoldExprClass:
1105  return CT_Dependent;
1106 
1107  case Expr::AsTypeExprClass:
1108  case Expr::BinaryConditionalOperatorClass:
1109  case Expr::BlockExprClass:
1110  case Expr::CUDAKernelCallExprClass:
1111  case Expr::DeclRefExprClass:
1112  case Expr::ObjCBridgedCastExprClass:
1113  case Expr::ObjCIndirectCopyRestoreExprClass:
1114  case Expr::ObjCProtocolExprClass:
1115  case Expr::ObjCSelectorExprClass:
1116  case Expr::OffsetOfExprClass:
1117  case Expr::PackExpansionExprClass:
1118  case Expr::PseudoObjectExprClass:
1119  case Expr::SubstNonTypeTemplateParmExprClass:
1120  case Expr::SubstNonTypeTemplateParmPackExprClass:
1121  case Expr::FunctionParmPackExprClass:
1122  case Expr::UnaryExprOrTypeTraitExprClass:
1123  case Expr::UnresolvedLookupExprClass:
1124  case Expr::UnresolvedMemberExprClass:
1125  case Expr::TypoExprClass:
1126  // FIXME: Can any of the above throw? If so, when?
1127  return CT_Cannot;
1128 
1129  case Expr::AddrLabelExprClass:
1130  case Expr::ArrayTypeTraitExprClass:
1131  case Expr::AtomicExprClass:
1132  case Expr::TypeTraitExprClass:
1133  case Expr::CXXBoolLiteralExprClass:
1134  case Expr::CXXNoexceptExprClass:
1135  case Expr::CXXNullPtrLiteralExprClass:
1136  case Expr::CXXPseudoDestructorExprClass:
1137  case Expr::CXXScalarValueInitExprClass:
1138  case Expr::CXXThisExprClass:
1139  case Expr::CXXUuidofExprClass:
1140  case Expr::CharacterLiteralClass:
1141  case Expr::ExpressionTraitExprClass:
1142  case Expr::FloatingLiteralClass:
1143  case Expr::GNUNullExprClass:
1144  case Expr::ImaginaryLiteralClass:
1145  case Expr::ImplicitValueInitExprClass:
1146  case Expr::IntegerLiteralClass:
1147  case Expr::NoInitExprClass:
1148  case Expr::ObjCEncodeExprClass:
1149  case Expr::ObjCStringLiteralClass:
1150  case Expr::ObjCBoolLiteralExprClass:
1151  case Expr::OpaqueValueExprClass:
1152  case Expr::PredefinedExprClass:
1153  case Expr::SizeOfPackExprClass:
1154  case Expr::StringLiteralClass:
1155  // These expressions can never throw.
1156  return CT_Cannot;
1157 
1158  case Expr::MSPropertyRefExprClass:
1159  llvm_unreachable("Invalid class for expression");
1160 
1161 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:
1162 #define STMT_RANGE(Base, First, Last)
1163 #define LAST_STMT_RANGE(BASE, FIRST, LAST)
1164 #define EXPR(CLASS, PARENT)
1165 #define ABSTRACT_STMT(STMT)
1166 #include "clang/AST/StmtNodes.inc"
1167  case Expr::NoStmtClass:
1168  llvm_unreachable("Invalid class for expression");
1169  }
1170  llvm_unreachable("Bogus StmtClass");
1171 }
1172 
1173 } // end namespace clang
CanThrowResult canThrow(const Expr *E)
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
CastKind getCastKind() const
Definition: Expr.h:2709
no exception specification
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn't been determined yet (either because...
Definition: Type.h:3208
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Defines the SourceManager interface.
bool isRecordType() const
Definition: Type.h:5289
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Evaluate the implicit exception specification for a defaulted special member function.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
A container of type source information.
Definition: Decl.h:60
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
The noexcept specifier has a bad expression.
Definition: Type.h:3186
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1572
const Expr * getCallee() const
Definition: Expr.h:2188
void clear()
Clear the base-paths results.
CK_Dynamic - A C++ dynamic_cast.
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isVoidType() const
Definition: Type.h:5426
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
unsigned getNumParams() const
Definition: Type.h:3133
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2537
bool hasAttr() const
Definition: DeclBase.h:487
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3138
bool isReferenceType() const
Definition: Type.h:5241
NoexceptResult
Result type of getNoexceptSpec().
Definition: Type.h:3184
bool isPRValue() const
Definition: Expr.h:354
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1708
Expr * getSubExpr()
Definition: Expr.h:2713
Microsoft throw(...) extension.
unsigned getDiagID() const
QualType getReturnType() const
Definition: Type.h:2952
Wrapper for source info for functions.
Definition: TypeLoc.h:1243
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
capture_init_iterator capture_init_end() const
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1518
Expr * getExprOperand() const
Definition: ExprCXX.h:589
Expr * getNoexceptExpr() const
Definition: Type.h:3198
bool isValueDependent() const
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3527
static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc)
QualType getTypeAsWritten() const
Definition: Expr.h:2849
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
QualType getType() const
Definition: Decl.h:538
bool isInvalid() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
QualType getParamType(unsigned i) const
Definition: Type.h:3134
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3166
capture_init_iterator capture_init_begin() const
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1512
CanThrowResult mergeCanThrow(CanThrowResult CT1, CanThrowResult CT2)
QualType getPointeeType() const
Definition: Type.cpp:414
StringRef getName() const
Return the actual identifier string.
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3142
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &O)
Definition: Type.h:3051
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:376
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6354
Defines the clang::TypeLoc interface and its subclasses.
There is no noexcept specifier.
Definition: Type.h:3185
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:303
bool isDependentType() const
Definition: Type.h:1727
bool IsDerivedFrom(QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
DeclarationName getDeclName() const
Definition: Decl.h:189
The result type of a method or function.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:611
static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC)
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification. If this depends on t...
Definition: Type.cpp:2680
CanThrowResult
Possible results from evaluation of a noexcept expression.
exception_iterator exception_begin() const
Definition: Type.h:3266
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:269
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl. It will iterate at least once ...
Definition: Redeclarable.h:228
Kind
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3028
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
bool CheckDistantExceptionSpec(QualType T)
bool CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range)
bool isValid() const
Return true if this is a valid SourceLocation object.
OverloadedOperatorKind getCXXOverloadedOperator() const
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
static bool hasImplicitExceptionSpec(FunctionDecl *Decl)
The noexcept specifier evaluates to true.
Definition: Type.h:3189
static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC)
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:2644
SourceLocation getBegin() const
bool isTypeDependent() const
Definition: Expr.h:166
const T * castAs() const
Definition: Type.h:5586
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2657
bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)
Determine if we're in a case where we need to (incorrectly) eagerly parse an exception specification ...
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:2868
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
QualType getType() const
Definition: Expr.h:125
not evaluated yet, for special member function
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1302
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1044
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1855
Defines the Diagnostic-related interfaces.
Decl * getCalleeDecl()
Definition: Expr.cpp:1160
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:803
const T * getAs() const
Definition: Type.h:5555
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:1807
bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc)
bool isFunctionType() const
Definition: Type.h:5229
CXXBasePath & front()
The noexcept specifier evaluates to false.
Definition: Type.h:3188
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1505
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:78
SourceManager & getSourceManager()
Definition: ASTContext.h:494
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1915
bool CheckParamExceptionSpec(const PartialDiagnostic &NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc)
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
bool isArrayType() const
Definition: Type.h:5271
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 hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3170
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
ASTContext & Context
Definition: Sema.h:295
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:507
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
bool isTypeOperand() const
Definition: ExprCXX.h:572
The noexcept specifier is dependent.
Definition: Type.h:3187
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
NamespaceDecl * getStdNamespace() const
void setType(QualType newType)
Definition: Decl.h:539
ArrayRef< QualType > exceptions() const
Definition: Type.h:3263
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2849
static const FunctionProtoType * GetUnderlyingFunction(QualType T)
Expr * IgnoreParens() LLVM_READONLY
Definition: Expr.cpp:2408
unsigned getNumExceptions() const
Definition: Type.h:3193