clang  10.0.0git
SemaExceptionSpec.cpp
Go to the documentation of this file.
1 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file provides Sema routines for C++ exception specification testing.
10 //
11 //===----------------------------------------------------------------------===//
12 
16 #include "clang/AST/Expr.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/StmtObjC.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 
80  Expr *NoexceptExpr,
82  // FIXME: This is bogus, a noexcept expression is not a condition.
83  ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr);
84  if (Converted.isInvalid()) {
85  EST = EST_NoexceptFalse;
86 
87  // Fill in an expression of 'false' as a fixup.
88  auto *BoolExpr = new (Context)
89  CXXBoolLiteralExpr(false, Context.BoolTy, NoexceptExpr->getBeginLoc());
91  Value = 0;
92  return ConstantExpr::Create(Context, BoolExpr, APValue{Value});
93  }
94 
95  if (Converted.get()->isValueDependent()) {
97  return Converted;
98  }
99 
102  Converted.get(), &Result,
103  diag::err_noexcept_needs_constant_expression,
104  /*AllowFold*/ false);
105  if (!Converted.isInvalid())
106  EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue;
107  return Converted;
108 }
109 
110 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
111 /// exception specification. Incomplete types, or pointers to incomplete types
112 /// other than void are not allowed.
113 ///
114 /// \param[in,out] T The exception type. This will be decayed to a pointer type
115 /// when the input is an array or a function type.
117  // C++11 [except.spec]p2:
118  // A type cv T, "array of T", or "function returning T" denoted
119  // in an exception-specification is adjusted to type T, "pointer to T", or
120  // "pointer to function returning T", respectively.
121  //
122  // We also apply this rule in C++98.
123  if (T->isArrayType())
125  else if (T->isFunctionType())
126  T = Context.getPointerType(T);
127 
128  int Kind = 0;
129  QualType PointeeT = T;
130  if (const PointerType *PT = T->getAs<PointerType>()) {
131  PointeeT = PT->getPointeeType();
132  Kind = 1;
133 
134  // cv void* is explicitly permitted, despite being a pointer to an
135  // incomplete type.
136  if (PointeeT->isVoidType())
137  return false;
138  } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
139  PointeeT = RT->getPointeeType();
140  Kind = 2;
141 
142  if (RT->isRValueReferenceType()) {
143  // C++11 [except.spec]p2:
144  // A type denoted in an exception-specification shall not denote [...]
145  // an rvalue reference type.
146  Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
147  << T << Range;
148  return true;
149  }
150  }
151 
152  // C++11 [except.spec]p2:
153  // A type denoted in an exception-specification shall not denote an
154  // incomplete type other than a class currently being defined [...].
155  // A type denoted in an exception-specification shall not denote a
156  // pointer or reference to an incomplete type, other than (cv) void* or a
157  // pointer or reference to a class currently being defined.
158  // In Microsoft mode, downgrade this to a warning.
159  unsigned DiagID = diag::err_incomplete_in_exception_spec;
160  bool ReturnValueOnError = true;
161  if (getLangOpts().MSVCCompat) {
162  DiagID = diag::ext_incomplete_in_exception_spec;
163  ReturnValueOnError = false;
164  }
165  if (!(PointeeT->isRecordType() &&
166  PointeeT->castAs<RecordType>()->isBeingDefined()) &&
167  RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
168  return ReturnValueOnError;
169 
170  return false;
171 }
172 
173 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
174 /// to member to a function with an exception specification. This means that
175 /// it is invalid to add another level of indirection.
177  // C++17 removes this rule in favor of putting exception specifications into
178  // the type system.
179  if (getLangOpts().CPlusPlus17)
180  return false;
181 
182  if (const PointerType *PT = T->getAs<PointerType>())
183  T = PT->getPointeeType();
184  else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
185  T = PT->getPointeeType();
186  else
187  return false;
188 
189  const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
190  if (!FnT)
191  return false;
192 
193  return FnT->hasExceptionSpec();
194 }
195 
196 const FunctionProtoType *
198  if (FPT->getExceptionSpecType() == EST_Unparsed) {
199  Diag(Loc, diag::err_exception_spec_not_parsed);
200  return nullptr;
201  }
202 
204  return FPT;
205 
206  FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
207  const FunctionProtoType *SourceFPT =
208  SourceDecl->getType()->castAs<FunctionProtoType>();
209 
210  // If the exception specification has already been resolved, just return it.
212  return SourceFPT;
213 
214  // Compute or instantiate the exception specification now.
215  if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
216  EvaluateImplicitExceptionSpec(Loc, SourceDecl);
217  else
218  InstantiateExceptionSpec(Loc, SourceDecl);
219 
220  const FunctionProtoType *Proto =
221  SourceDecl->getType()->castAs<FunctionProtoType>();
222  if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
223  Diag(Loc, diag::err_exception_spec_not_parsed);
224  Proto = nullptr;
225  }
226  return Proto;
227 }
228 
229 void
232  // If we've fully resolved the exception specification, notify listeners.
234  if (auto *Listener = getASTMutationListener())
235  Listener->ResolvedExceptionSpec(FD);
236 
237  for (FunctionDecl *Redecl : FD->redecls())
238  Context.adjustExceptionSpec(Redecl, ESI);
239 }
240 
241 static bool exceptionSpecNotKnownYet(const FunctionDecl *FD) {
242  auto *MD = dyn_cast<CXXMethodDecl>(FD);
243  if (!MD)
244  return false;
245 
246  auto EST = MD->getType()->castAs<FunctionProtoType>()->getExceptionSpecType();
247  return EST == EST_Unparsed ||
248  (EST == EST_Unevaluated && MD->getParent()->isBeingDefined());
249 }
250 
252  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
253  const FunctionProtoType *Old, SourceLocation OldLoc,
254  const FunctionProtoType *New, SourceLocation NewLoc,
255  bool *MissingExceptionSpecification = nullptr,
256  bool *MissingEmptyExceptionSpecification = nullptr,
257  bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false);
258 
259 /// Determine whether a function has an implicitly-generated exception
260 /// specification.
262  if (!isa<CXXDestructorDecl>(Decl) &&
263  Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
264  Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
265  return false;
266 
267  // For a function that the user didn't declare:
268  // - if this is a destructor, its exception specification is implicit.
269  // - if this is 'operator delete' or 'operator delete[]', the exception
270  // specification is as-if an explicit exception specification was given
271  // (per [basic.stc.dynamic]p2).
272  if (!Decl->getTypeSourceInfo())
273  return isa<CXXDestructorDecl>(Decl);
274 
275  auto *Ty = Decl->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
276  return !Ty->hasExceptionSpec();
277 }
278 
280  // Just completely ignore this under -fno-exceptions prior to C++17.
281  // In C++17 onwards, the exception specification is part of the type and
282  // we will diagnose mismatches anyway, so it's better to check for them here.
283  if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17)
284  return false;
285 
287  bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
288  bool MissingExceptionSpecification = false;
289  bool MissingEmptyExceptionSpecification = false;
290 
291  unsigned DiagID = diag::err_mismatched_exception_spec;
292  bool ReturnValueOnError = true;
293  if (getLangOpts().MSVCCompat) {
294  DiagID = diag::ext_mismatched_exception_spec;
295  ReturnValueOnError = false;
296  }
297 
298  // If we're befriending a member function of a class that's currently being
299  // defined, we might not be able to work out its exception specification yet.
300  // If not, defer the check until later.
302  DelayedEquivalentExceptionSpecChecks.push_back({New, Old});
303  return false;
304  }
305 
306  // Check the types as written: they must match before any exception
307  // specification adjustment is applied.
309  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
310  Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
311  New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
312  &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
313  /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
314  // C++11 [except.spec]p4 [DR1492]:
315  // If a declaration of a function has an implicit
316  // exception-specification, other declarations of the function shall
317  // not specify an exception-specification.
318  if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions &&
320  Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
321  << hasImplicitExceptionSpec(Old);
322  if (Old->getLocation().isValid())
323  Diag(Old->getLocation(), diag::note_previous_declaration);
324  }
325  return false;
326  }
327 
328  // The failure was something other than an missing exception
329  // specification; return an error, except in MS mode where this is a warning.
330  if (!MissingExceptionSpecification)
331  return ReturnValueOnError;
332 
333  const FunctionProtoType *NewProto =
334  New->getType()->castAs<FunctionProtoType>();
335 
336  // The new function declaration is only missing an empty exception
337  // specification "throw()". If the throw() specification came from a
338  // function in a system header that has C linkage, just add an empty
339  // exception specification to the "new" declaration. Note that C library
340  // implementations are permitted to add these nothrow exception
341  // specifications.
342  //
343  // Likewise if the old function is a builtin.
344  if (MissingEmptyExceptionSpecification && NewProto &&
345  (Old->getLocation().isInvalid() ||
347  Old->getBuiltinID()) &&
348  Old->isExternC()) {
350  NewProto->getReturnType(), NewProto->getParamTypes(),
352  return false;
353  }
354 
355  const FunctionProtoType *OldProto =
356  Old->getType()->castAs<FunctionProtoType>();
357 
359  if (ESI.Type == EST_Dynamic) {
360  // FIXME: What if the exceptions are described in terms of the old
361  // prototype's parameters?
362  ESI.Exceptions = OldProto->exceptions();
363  }
364 
365  if (ESI.Type == EST_NoexceptFalse)
366  ESI.Type = EST_None;
367  if (ESI.Type == EST_NoexceptTrue)
368  ESI.Type = EST_BasicNoexcept;
369 
370  // For dependent noexcept, we can't just take the expression from the old
371  // prototype. It likely contains references to the old prototype's parameters.
372  if (ESI.Type == EST_DependentNoexcept) {
373  New->setInvalidDecl();
374  } else {
375  // Update the type of the function with the appropriate exception
376  // specification.
378  NewProto->getReturnType(), NewProto->getParamTypes(),
379  NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
380  }
381 
382  if (getLangOpts().MSVCCompat && ESI.Type != EST_DependentNoexcept) {
383  // Allow missing exception specifications in redeclarations as an extension.
384  DiagID = diag::ext_ms_missing_exception_specification;
385  ReturnValueOnError = false;
386  } else if (New->isReplaceableGlobalAllocationFunction() &&
387  ESI.Type != EST_DependentNoexcept) {
388  // Allow missing exception specifications in redeclarations as an extension,
389  // when declaring a replaceable global allocation function.
390  DiagID = diag::ext_missing_exception_specification;
391  ReturnValueOnError = false;
392  } else if (ESI.Type == EST_NoThrow) {
393  // Allow missing attribute 'nothrow' in redeclarations, since this is a very
394  // common omission.
395  DiagID = diag::ext_missing_exception_specification;
396  ReturnValueOnError = false;
397  } else {
398  DiagID = diag::err_missing_exception_specification;
399  ReturnValueOnError = true;
400  }
401 
402  // Warn about the lack of exception specification.
403  SmallString<128> ExceptionSpecString;
404  llvm::raw_svector_ostream OS(ExceptionSpecString);
405  switch (OldProto->getExceptionSpecType()) {
406  case EST_DynamicNone:
407  OS << "throw()";
408  break;
409 
410  case EST_Dynamic: {
411  OS << "throw(";
412  bool OnFirstException = true;
413  for (const auto &E : OldProto->exceptions()) {
414  if (OnFirstException)
415  OnFirstException = false;
416  else
417  OS << ", ";
418 
419  OS << E.getAsString(getPrintingPolicy());
420  }
421  OS << ")";
422  break;
423  }
424 
425  case EST_BasicNoexcept:
426  OS << "noexcept";
427  break;
428 
430  case EST_NoexceptFalse:
431  case EST_NoexceptTrue:
432  OS << "noexcept(";
433  assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
434  OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
435  OS << ")";
436  break;
437  case EST_NoThrow:
438  OS <<"__attribute__((nothrow))";
439  break;
440  case EST_None:
441  case EST_MSAny:
442  case EST_Unevaluated:
443  case EST_Uninstantiated:
444  case EST_Unparsed:
445  llvm_unreachable("This spec type is compatible with none.");
446  }
447 
448  SourceLocation FixItLoc;
449  if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
450  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
451  // FIXME: Preserve enough information so that we can produce a correct fixit
452  // location when there is a trailing return type.
453  if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>())
454  if (!FTLoc.getTypePtr()->hasTrailingReturn())
455  FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
456  }
457 
458  if (FixItLoc.isInvalid())
459  Diag(New->getLocation(), DiagID)
460  << New << OS.str();
461  else {
462  Diag(New->getLocation(), DiagID)
463  << New << OS.str()
464  << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
465  }
466 
467  if (Old->getLocation().isValid())
468  Diag(Old->getLocation(), diag::note_previous_declaration);
469 
470  return ReturnValueOnError;
471 }
472 
473 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
474 /// exception specifications. Exception specifications are equivalent if
475 /// they allow exactly the same set of exception types. It does not matter how
476 /// that is achieved. See C++ [except.spec]p2.
478  const FunctionProtoType *Old, SourceLocation OldLoc,
479  const FunctionProtoType *New, SourceLocation NewLoc) {
480  if (!getLangOpts().CXXExceptions)
481  return false;
482 
483  unsigned DiagID = diag::err_mismatched_exception_spec;
484  if (getLangOpts().MSVCCompat)
485  DiagID = diag::ext_mismatched_exception_spec;
487  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
488  Old, OldLoc, New, NewLoc);
489 
490  // In Microsoft mode, mismatching exception specifications just cause a warning.
491  if (getLangOpts().MSVCCompat)
492  return false;
493  return Result;
494 }
495 
496 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
497 /// exception specifications. See C++ [except.spec]p3.
498 ///
499 /// \return \c false if the exception specifications match, \c true if there is
500 /// a problem. If \c true is returned, either a diagnostic has already been
501 /// produced or \c *MissingExceptionSpecification is set to \c true.
503  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
504  const FunctionProtoType *Old, SourceLocation OldLoc,
505  const FunctionProtoType *New, SourceLocation NewLoc,
506  bool *MissingExceptionSpecification,
507  bool *MissingEmptyExceptionSpecification,
508  bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) {
509  if (MissingExceptionSpecification)
510  *MissingExceptionSpecification = false;
511 
512  if (MissingEmptyExceptionSpecification)
513  *MissingEmptyExceptionSpecification = false;
514 
515  Old = S.ResolveExceptionSpec(NewLoc, Old);
516  if (!Old)
517  return false;
518  New = S.ResolveExceptionSpec(NewLoc, New);
519  if (!New)
520  return false;
521 
522  // C++0x [except.spec]p3: Two exception-specifications are compatible if:
523  // - both are non-throwing, regardless of their form,
524  // - both have the form noexcept(constant-expression) and the constant-
525  // expressions are equivalent,
526  // - both are dynamic-exception-specifications that have the same set of
527  // adjusted types.
528  //
529  // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
530  // of the form throw(), noexcept, or noexcept(constant-expression) where the
531  // constant-expression yields true.
532  //
533  // C++0x [except.spec]p4: If any declaration of a function has an exception-
534  // specifier that is not a noexcept-specification allowing all exceptions,
535  // all declarations [...] of that function shall have a compatible
536  // exception-specification.
537  //
538  // That last point basically means that noexcept(false) matches no spec.
539  // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
540 
543 
544  assert(!isUnresolvedExceptionSpec(OldEST) &&
545  !isUnresolvedExceptionSpec(NewEST) &&
546  "Shouldn't see unknown exception specifications here");
547 
548  CanThrowResult OldCanThrow = Old->canThrow();
549  CanThrowResult NewCanThrow = New->canThrow();
550 
551  // Any non-throwing specifications are compatible.
552  if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot)
553  return false;
554 
555  // Any throws-anything specifications are usually compatible.
556  if (OldCanThrow == CT_Can && OldEST != EST_Dynamic &&
557  NewCanThrow == CT_Can && NewEST != EST_Dynamic) {
558  // The exception is that the absence of an exception specification only
559  // matches noexcept(false) for functions, as described above.
560  if (!AllowNoexceptAllMatchWithNoSpec &&
561  ((OldEST == EST_None && NewEST == EST_NoexceptFalse) ||
562  (OldEST == EST_NoexceptFalse && NewEST == EST_None))) {
563  // This is the disallowed case.
564  } else {
565  return false;
566  }
567  }
568 
569  // C++14 [except.spec]p3:
570  // Two exception-specifications are compatible if [...] both have the form
571  // noexcept(constant-expression) and the constant-expressions are equivalent
572  if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) {
573  llvm::FoldingSetNodeID OldFSN, NewFSN;
574  Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true);
575  New->getNoexceptExpr()->Profile(NewFSN, S.Context, true);
576  if (OldFSN == NewFSN)
577  return false;
578  }
579 
580  // Dynamic exception specifications with the same set of adjusted types
581  // are compatible.
582  if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) {
583  bool Success = true;
584  // Both have a dynamic exception spec. Collect the first set, then compare
585  // to the second.
586  llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
587  for (const auto &I : Old->exceptions())
588  OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
589 
590  for (const auto &I : New->exceptions()) {
592  if (OldTypes.count(TypePtr))
593  NewTypes.insert(TypePtr);
594  else {
595  Success = false;
596  break;
597  }
598  }
599 
600  if (Success && OldTypes.size() == NewTypes.size())
601  return false;
602  }
603 
604  // As a special compatibility feature, under C++0x we accept no spec and
605  // throw(std::bad_alloc) as equivalent for operator new and operator new[].
606  // This is because the implicit declaration changed, but old code would break.
607  if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) {
608  const FunctionProtoType *WithExceptions = nullptr;
609  if (OldEST == EST_None && NewEST == EST_Dynamic)
610  WithExceptions = New;
611  else if (OldEST == EST_Dynamic && NewEST == EST_None)
612  WithExceptions = Old;
613  if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
614  // One has no spec, the other throw(something). If that something is
615  // std::bad_alloc, all conditions are met.
616  QualType Exception = *WithExceptions->exception_begin();
617  if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
618  IdentifierInfo* Name = ExRecord->getIdentifier();
619  if (Name && Name->getName() == "bad_alloc") {
620  // It's called bad_alloc, but is it in std?
621  if (ExRecord->isInStdNamespace()) {
622  return false;
623  }
624  }
625  }
626  }
627  }
628 
629  // If the caller wants to handle the case that the new function is
630  // incompatible due to a missing exception specification, let it.
631  if (MissingExceptionSpecification && OldEST != EST_None &&
632  NewEST == EST_None) {
633  // The old type has an exception specification of some sort, but
634  // the new type does not.
635  *MissingExceptionSpecification = true;
636 
637  if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) {
638  // The old type has a throw() or noexcept(true) exception specification
639  // and the new type has no exception specification, and the caller asked
640  // to handle this itself.
641  *MissingEmptyExceptionSpecification = true;
642  }
643 
644  return true;
645  }
646 
647  S.Diag(NewLoc, DiagID);
648  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
649  S.Diag(OldLoc, NoteID);
650  return true;
651 }
652 
654  const PartialDiagnostic &NoteID,
655  const FunctionProtoType *Old,
656  SourceLocation OldLoc,
657  const FunctionProtoType *New,
658  SourceLocation NewLoc) {
659  if (!getLangOpts().CXXExceptions)
660  return false;
661  return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc,
662  New, NewLoc);
663 }
664 
665 bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) {
666  // [except.handle]p3:
667  // A handler is a match for an exception object of type E if:
668 
669  // HandlerType must be ExceptionType or derived from it, or pointer or
670  // reference to such types.
671  const ReferenceType *RefTy = HandlerType->getAs<ReferenceType>();
672  if (RefTy)
673  HandlerType = RefTy->getPointeeType();
674 
675  // -- the handler is of type cv T or cv T& and E and T are the same type
676  if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType))
677  return true;
678 
679  // FIXME: ObjC pointer types?
680  if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) {
681  if (RefTy && (!HandlerType.isConstQualified() ||
682  HandlerType.isVolatileQualified()))
683  return false;
684 
685  // -- the handler is of type cv T or const T& where T is a pointer or
686  // pointer to member type and E is std::nullptr_t
687  if (ExceptionType->isNullPtrType())
688  return true;
689 
690  // -- the handler is of type cv T or const T& where T is a pointer or
691  // pointer to member type and E is a pointer or pointer to member type
692  // that can be converted to T by one or more of
693  // -- a qualification conversion
694  // -- a function pointer conversion
695  bool LifetimeConv;
697  // FIXME: Should we treat the exception as catchable if a lifetime
698  // conversion is required?
699  if (IsQualificationConversion(ExceptionType, HandlerType, false,
700  LifetimeConv) ||
701  IsFunctionConversion(ExceptionType, HandlerType, Result))
702  return true;
703 
704  // -- a standard pointer conversion [...]
705  if (!ExceptionType->isPointerType() || !HandlerType->isPointerType())
706  return false;
707 
708  // Handle the "qualification conversion" portion.
709  Qualifiers EQuals, HQuals;
710  ExceptionType = Context.getUnqualifiedArrayType(
711  ExceptionType->getPointeeType(), EQuals);
712  HandlerType = Context.getUnqualifiedArrayType(
713  HandlerType->getPointeeType(), HQuals);
714  if (!HQuals.compatiblyIncludes(EQuals))
715  return false;
716 
717  if (HandlerType->isVoidType() && ExceptionType->isObjectType())
718  return true;
719 
720  // The only remaining case is a derived-to-base conversion.
721  }
722 
723  // -- the handler is of type cg T or cv T& and T is an unambiguous public
724  // base class of E
725  if (!ExceptionType->isRecordType() || !HandlerType->isRecordType())
726  return false;
727  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
728  /*DetectVirtual=*/false);
729  if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) ||
730  Paths.isAmbiguous(Context.getCanonicalType(HandlerType)))
731  return false;
732 
733  // Do this check from a context without privileges.
734  switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType,
735  Paths.front(),
736  /*Diagnostic*/ 0,
737  /*ForceCheck*/ true,
738  /*ForceUnprivileged*/ true)) {
739  case AR_accessible: return true;
740  case AR_inaccessible: return false;
741  case AR_dependent:
742  llvm_unreachable("access check dependent for unprivileged context");
743  case AR_delayed:
744  llvm_unreachable("access check delayed in non-declaration");
745  }
746  llvm_unreachable("unexpected access check result");
747 }
748 
749 /// CheckExceptionSpecSubset - Check whether the second function type's
750 /// exception specification is a subset (or equivalent) of the first function
751 /// type. This is used by override and pointer assignment checks.
753  const PartialDiagnostic &NestedDiagID,
754  const PartialDiagnostic &NoteID,
755  const PartialDiagnostic &NoThrowDiagID,
756  const FunctionProtoType *Superset,
757  SourceLocation SuperLoc,
758  const FunctionProtoType *Subset,
759  SourceLocation SubLoc) {
760 
761  // Just auto-succeed under -fno-exceptions.
762  if (!getLangOpts().CXXExceptions)
763  return false;
764 
765  // FIXME: As usual, we could be more specific in our error messages, but
766  // that better waits until we've got types with source locations.
767 
768  if (!SubLoc.isValid())
769  SubLoc = SuperLoc;
770 
771  // Resolve the exception specifications, if needed.
772  Superset = ResolveExceptionSpec(SuperLoc, Superset);
773  if (!Superset)
774  return false;
775  Subset = ResolveExceptionSpec(SubLoc, Subset);
776  if (!Subset)
777  return false;
778 
779  ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
781  assert(!isUnresolvedExceptionSpec(SuperEST) &&
782  !isUnresolvedExceptionSpec(SubEST) &&
783  "Shouldn't see unknown exception specifications here");
784 
785  // If there are dependent noexcept specs, assume everything is fine. Unlike
786  // with the equivalency check, this is safe in this case, because we don't
787  // want to merge declarations. Checks after instantiation will catch any
788  // omissions we make here.
789  if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept)
790  return false;
791 
792  CanThrowResult SuperCanThrow = Superset->canThrow();
793  CanThrowResult SubCanThrow = Subset->canThrow();
794 
795  // If the superset contains everything or the subset contains nothing, we're
796  // done.
797  if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) ||
798  SubCanThrow == CT_Cannot)
799  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
800  Subset, SubLoc);
801 
802  // Allow __declspec(nothrow) to be missing on redeclaration as an extension in
803  // some cases.
804  if (NoThrowDiagID.getDiagID() != 0 && SubCanThrow == CT_Can &&
805  SuperCanThrow == CT_Cannot && SuperEST == EST_NoThrow) {
806  Diag(SubLoc, NoThrowDiagID);
807  if (NoteID.getDiagID() != 0)
808  Diag(SuperLoc, NoteID);
809  return true;
810  }
811 
812  // If the subset contains everything or the superset contains nothing, we've
813  // failed.
814  if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) ||
815  SuperCanThrow == CT_Cannot) {
816  Diag(SubLoc, DiagID);
817  if (NoteID.getDiagID() != 0)
818  Diag(SuperLoc, NoteID);
819  return true;
820  }
821 
822  assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
823  "Exception spec subset: non-dynamic case slipped through.");
824 
825  // Neither contains everything or nothing. Do a proper comparison.
826  for (QualType SubI : Subset->exceptions()) {
827  if (const ReferenceType *RefTy = SubI->getAs<ReferenceType>())
828  SubI = RefTy->getPointeeType();
829 
830  // Make sure it's in the superset.
831  bool Contained = false;
832  for (QualType SuperI : Superset->exceptions()) {
833  // [except.spec]p5:
834  // the target entity shall allow at least the exceptions allowed by the
835  // source
836  //
837  // We interpret this as meaning that a handler for some target type would
838  // catch an exception of each source type.
839  if (handlerCanCatch(SuperI, SubI)) {
840  Contained = true;
841  break;
842  }
843  }
844  if (!Contained) {
845  Diag(SubLoc, DiagID);
846  if (NoteID.getDiagID() != 0)
847  Diag(SuperLoc, NoteID);
848  return true;
849  }
850  }
851  // We've run half the gauntlet.
852  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
853  Subset, SubLoc);
854 }
855 
856 static bool
858  const PartialDiagnostic &NoteID, QualType Target,
859  SourceLocation TargetLoc, QualType Source,
860  SourceLocation SourceLoc) {
861  const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
862  if (!TFunc)
863  return false;
864  const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
865  if (!SFunc)
866  return false;
867 
868  return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
869  SFunc, SourceLoc);
870 }
871 
872 /// CheckParamExceptionSpec - Check if the parameter and return types of the
873 /// two functions have equivalent exception specs. This is part of the
874 /// assignment and override compatibility check. We do not check the parameters
875 /// of parameter function pointers recursively, as no sane programmer would
876 /// even be able to write such a function type.
878  const PartialDiagnostic &NoteID,
879  const FunctionProtoType *Target,
880  SourceLocation TargetLoc,
881  const FunctionProtoType *Source,
882  SourceLocation SourceLoc) {
883  auto RetDiag = DiagID;
884  RetDiag << 0;
886  *this, RetDiag, PDiag(),
887  Target->getReturnType(), TargetLoc, Source->getReturnType(),
888  SourceLoc))
889  return true;
890 
891  // We shouldn't even be testing this unless the arguments are otherwise
892  // compatible.
893  assert(Target->getNumParams() == Source->getNumParams() &&
894  "Functions have different argument counts.");
895  for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
896  auto ParamDiag = DiagID;
897  ParamDiag << 1;
899  *this, ParamDiag, PDiag(),
900  Target->getParamType(i), TargetLoc, Source->getParamType(i),
901  SourceLoc))
902  return true;
903  }
904  return false;
905 }
906 
908  // First we check for applicability.
909  // Target type must be a function, function pointer or function reference.
910  const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
911  if (!ToFunc || ToFunc->hasDependentExceptionSpec())
912  return false;
913 
914  // SourceType must be a function or function pointer.
915  const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
916  if (!FromFunc || FromFunc->hasDependentExceptionSpec())
917  return false;
918 
919  unsigned DiagID = diag::err_incompatible_exception_specs;
920  unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
921  // This is not an error in C++17 onwards, unless the noexceptness doesn't
922  // match, but in that case we have a full-on type mismatch, not just a
923  // type sugar mismatch.
924  if (getLangOpts().CPlusPlus17) {
925  DiagID = diag::warn_incompatible_exception_specs;
926  NestedDiagID = diag::warn_deep_exception_specs_differ;
927  }
928 
929  // Now we've got the correct types on both sides, check their compatibility.
930  // This means that the source of the conversion can only throw a subset of
931  // the exceptions of the target, and any exception specs on arguments or
932  // return types must be equivalent.
933  //
934  // FIXME: If there is a nested dependent exception specification, we should
935  // not be checking it here. This is fine:
936  // template<typename T> void f() {
937  // void (*p)(void (*) throw(T));
938  // void (*q)(void (*) throw(int)) = p;
939  // }
940  // ... because it might be instantiated with T=int.
942  PDiag(DiagID), PDiag(NestedDiagID), PDiag(), PDiag(), ToFunc,
943  From->getSourceRange().getBegin(), FromFunc, SourceLocation()) &&
944  !getLangOpts().CPlusPlus17;
945 }
946 
948  const CXXMethodDecl *Old) {
949  // If the new exception specification hasn't been parsed yet, skip the check.
950  // We'll get called again once it's been parsed.
951  if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
952  EST_Unparsed)
953  return false;
954 
955  // Don't check uninstantiated template destructors at all. We can only
956  // synthesize correct specs after the template is instantiated.
957  if (isa<CXXDestructorDecl>(New) && New->getParent()->isDependentType())
958  return false;
959 
960  // If the old exception specification hasn't been parsed yet, or the new
961  // exception specification can't be computed yet, remember that we need to
962  // perform this check when we get to the end of the outermost
963  // lexically-surrounding class.
965  DelayedOverridingExceptionSpecChecks.push_back({New, Old});
966  return false;
967  }
968 
969  unsigned DiagID = diag::err_override_exception_spec;
970  if (getLangOpts().MSVCCompat)
971  DiagID = diag::ext_override_exception_spec;
972  return CheckExceptionSpecSubset(PDiag(DiagID),
973  PDiag(diag::err_deep_exception_specs_differ),
974  PDiag(diag::note_overridden_virtual_function),
975  PDiag(diag::ext_override_exception_spec),
976  Old->getType()->castAs<FunctionProtoType>(),
977  Old->getLocation(),
978  New->getType()->castAs<FunctionProtoType>(),
979  New->getLocation());
980 }
981 
982 static CanThrowResult canSubStmtsThrow(Sema &Self, const Stmt *S) {
984  for (const Stmt *SubStmt : S->children()) {
985  if (!SubStmt)
986  continue;
987  R = mergeCanThrow(R, Self.canThrow(SubStmt));
988  if (R == CT_Can)
989  break;
990  }
991  return R;
992 }
993 
994 /// Determine whether the callee of a particular function call can throw.
995 /// E and D are both optional, but at least one of E and Loc must be specified.
996 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D,
997  SourceLocation Loc = SourceLocation()) {
998  // As an extension, we assume that __attribute__((nothrow)) functions don't
999  // throw.
1000  if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
1001  return CT_Cannot;
1002 
1003  QualType T;
1004 
1005  // In C++1z, just look at the function type of the callee.
1006  if (S.getLangOpts().CPlusPlus17 && E && isa<CallExpr>(E)) {
1007  E = cast<CallExpr>(E)->getCallee();
1008  T = E->getType();
1009  if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
1010  // Sadly we don't preserve the actual type as part of the "bound member"
1011  // placeholder, so we need to reconstruct it.
1012  E = E->IgnoreParenImpCasts();
1013 
1014  // Could be a call to a pointer-to-member or a plain member access.
1015  if (auto *Op = dyn_cast<BinaryOperator>(E)) {
1016  assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
1017  T = Op->getRHS()->getType()
1018  ->castAs<MemberPointerType>()->getPointeeType();
1019  } else {
1020  T = cast<MemberExpr>(E)->getMemberDecl()->getType();
1021  }
1022  }
1023  } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
1024  T = VD->getType();
1025  else
1026  // If we have no clue what we're calling, assume the worst.
1027  return CT_Can;
1028 
1029  const FunctionProtoType *FT;
1030  if ((FT = T->getAs<FunctionProtoType>())) {
1031  } else if (const PointerType *PT = T->getAs<PointerType>())
1032  FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1033  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1034  FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1035  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1036  FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1037  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1038  FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1039 
1040  if (!FT)
1041  return CT_Can;
1042 
1043  FT = S.ResolveExceptionSpec(Loc.isInvalid() ? E->getBeginLoc() : Loc, FT);
1044  if (!FT)
1045  return CT_Can;
1046 
1047  return FT->canThrow();
1048 }
1049 
1050 static CanThrowResult canVarDeclThrow(Sema &Self, const VarDecl *VD) {
1052 
1053  // Initialization might throw.
1054  if (!VD->isUsableInConstantExpressions(Self.Context))
1055  if (const Expr *Init = VD->getInit())
1056  CT = mergeCanThrow(CT, Self.canThrow(Init));
1057 
1058  // Destructor might throw.
1060  if (auto *RD =
1062  if (auto *Dtor = RD->getDestructor()) {
1063  CT = mergeCanThrow(
1064  CT, canCalleeThrow(Self, nullptr, Dtor, VD->getLocation()));
1065  }
1066  }
1067  }
1068 
1069  // If this is a decomposition declaration, bindings might throw.
1070  if (auto *DD = dyn_cast<DecompositionDecl>(VD))
1071  for (auto *B : DD->bindings())
1072  if (auto *HD = B->getHoldingVar())
1073  CT = mergeCanThrow(CT, canVarDeclThrow(Self, HD));
1074 
1075  return CT;
1076 }
1077 
1079  if (DC->isTypeDependent())
1080  return CT_Dependent;
1081 
1082  if (!DC->getTypeAsWritten()->isReferenceType())
1083  return CT_Cannot;
1084 
1085  if (DC->getSubExpr()->isTypeDependent())
1086  return CT_Dependent;
1087 
1088  return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
1089 }
1090 
1092  if (DC->isTypeOperand())
1093  return CT_Cannot;
1094 
1095  Expr *Op = DC->getExprOperand();
1096  if (Op->isTypeDependent())
1097  return CT_Dependent;
1098 
1099  const RecordType *RT = Op->getType()->getAs<RecordType>();
1100  if (!RT)
1101  return CT_Cannot;
1102 
1103  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1104  return CT_Cannot;
1105 
1106  if (Op->Classify(S.Context).isPRValue())
1107  return CT_Cannot;
1108 
1109  return CT_Can;
1110 }
1111 
1113  // C++ [expr.unary.noexcept]p3:
1114  // [Can throw] if in a potentially-evaluated context the expression would
1115  // contain:
1116  switch (S->getStmtClass()) {
1117  case Expr::ConstantExprClass:
1118  return canThrow(cast<ConstantExpr>(S)->getSubExpr());
1119 
1120  case Expr::CXXThrowExprClass:
1121  // - a potentially evaluated throw-expression
1122  return CT_Can;
1123 
1124  case Expr::CXXDynamicCastExprClass: {
1125  // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1126  // where T is a reference type, that requires a run-time check
1127  auto *CE = cast<CXXDynamicCastExpr>(S);
1128  // FIXME: Properly determine whether a variably-modified type can throw.
1129  if (CE->getType()->isVariablyModifiedType())
1130  return CT_Can;
1132  if (CT == CT_Can)
1133  return CT;
1134  return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
1135  }
1136 
1137  case Expr::CXXTypeidExprClass:
1138  // - a potentially evaluated typeid expression applied to a glvalue
1139  // expression whose type is a polymorphic class type
1140  return canTypeidThrow(*this, cast<CXXTypeidExpr>(S));
1141 
1142  // - a potentially evaluated call to a function, member function, function
1143  // pointer, or member function pointer that does not have a non-throwing
1144  // exception-specification
1145  case Expr::CallExprClass:
1146  case Expr::CXXMemberCallExprClass:
1147  case Expr::CXXOperatorCallExprClass:
1148  case Expr::UserDefinedLiteralClass: {
1149  const CallExpr *CE = cast<CallExpr>(S);
1150  CanThrowResult CT;
1151  if (CE->isTypeDependent())
1152  CT = CT_Dependent;
1153  else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1154  CT = CT_Cannot;
1155  else
1156  CT = canCalleeThrow(*this, CE, CE->getCalleeDecl());
1157  if (CT == CT_Can)
1158  return CT;
1159  return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
1160  }
1161 
1162  case Expr::CXXConstructExprClass:
1163  case Expr::CXXTemporaryObjectExprClass: {
1164  auto *CE = cast<CXXConstructExpr>(S);
1165  // FIXME: Properly determine whether a variably-modified type can throw.
1166  if (CE->getType()->isVariablyModifiedType())
1167  return CT_Can;
1168  CanThrowResult CT = canCalleeThrow(*this, CE, CE->getConstructor());
1169  if (CT == CT_Can)
1170  return CT;
1171  return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
1172  }
1173 
1174  case Expr::CXXInheritedCtorInitExprClass: {
1175  auto *ICIE = cast<CXXInheritedCtorInitExpr>(S);
1176  return canCalleeThrow(*this, ICIE, ICIE->getConstructor());
1177  }
1178 
1179  case Expr::LambdaExprClass: {
1180  const LambdaExpr *Lambda = cast<LambdaExpr>(S);
1183  Cap = Lambda->capture_init_begin(),
1184  CapEnd = Lambda->capture_init_end();
1185  Cap != CapEnd; ++Cap)
1186  CT = mergeCanThrow(CT, canThrow(*Cap));
1187  return CT;
1188  }
1189 
1190  case Expr::CXXNewExprClass: {
1191  auto *NE = cast<CXXNewExpr>(S);
1192  CanThrowResult CT;
1193  if (NE->isTypeDependent())
1194  CT = CT_Dependent;
1195  else
1196  CT = canCalleeThrow(*this, NE, NE->getOperatorNew());
1197  if (CT == CT_Can)
1198  return CT;
1199  return mergeCanThrow(CT, canSubStmtsThrow(*this, NE));
1200  }
1201 
1202  case Expr::CXXDeleteExprClass: {
1203  auto *DE = cast<CXXDeleteExpr>(S);
1204  CanThrowResult CT;
1205  QualType DTy = DE->getDestroyedType();
1206  if (DTy.isNull() || DTy->isDependentType()) {
1207  CT = CT_Dependent;
1208  } else {
1209  CT = canCalleeThrow(*this, DE, DE->getOperatorDelete());
1210  if (const RecordType *RT = DTy->getAs<RecordType>()) {
1211  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1212  const CXXDestructorDecl *DD = RD->getDestructor();
1213  if (DD)
1214  CT = mergeCanThrow(CT, canCalleeThrow(*this, DE, DD));
1215  }
1216  if (CT == CT_Can)
1217  return CT;
1218  }
1219  return mergeCanThrow(CT, canSubStmtsThrow(*this, DE));
1220  }
1221 
1222  case Expr::CXXBindTemporaryExprClass: {
1223  auto *BTE = cast<CXXBindTemporaryExpr>(S);
1224  // The bound temporary has to be destroyed again, which might throw.
1225  CanThrowResult CT =
1226  canCalleeThrow(*this, BTE, BTE->getTemporary()->getDestructor());
1227  if (CT == CT_Can)
1228  return CT;
1229  return mergeCanThrow(CT, canSubStmtsThrow(*this, BTE));
1230  }
1231 
1232  case Expr::PseudoObjectExprClass: {
1233  auto *POE = cast<PseudoObjectExpr>(S);
1235  for (const Expr *E : POE->semantics()) {
1236  CT = mergeCanThrow(CT, canThrow(E));
1237  if (CT == CT_Can)
1238  break;
1239  }
1240  return CT;
1241  }
1242 
1243  // ObjC message sends are like function calls, but never have exception
1244  // specs.
1245  case Expr::ObjCMessageExprClass:
1246  case Expr::ObjCPropertyRefExprClass:
1247  case Expr::ObjCSubscriptRefExprClass:
1248  return CT_Can;
1249 
1250  // All the ObjC literals that are implemented as calls are
1251  // potentially throwing unless we decide to close off that
1252  // possibility.
1253  case Expr::ObjCArrayLiteralClass:
1254  case Expr::ObjCDictionaryLiteralClass:
1255  case Expr::ObjCBoxedExprClass:
1256  return CT_Can;
1257 
1258  // Many other things have subexpressions, so we have to test those.
1259  // Some are simple:
1260  case Expr::CoawaitExprClass:
1261  case Expr::ConditionalOperatorClass:
1262  case Expr::CoyieldExprClass:
1263  case Expr::CXXRewrittenBinaryOperatorClass:
1264  case Expr::CXXStdInitializerListExprClass:
1265  case Expr::DesignatedInitExprClass:
1266  case Expr::DesignatedInitUpdateExprClass:
1267  case Expr::ExprWithCleanupsClass:
1268  case Expr::ExtVectorElementExprClass:
1269  case Expr::InitListExprClass:
1270  case Expr::ArrayInitLoopExprClass:
1271  case Expr::MemberExprClass:
1272  case Expr::ObjCIsaExprClass:
1273  case Expr::ObjCIvarRefExprClass:
1274  case Expr::ParenExprClass:
1275  case Expr::ParenListExprClass:
1276  case Expr::ShuffleVectorExprClass:
1277  case Expr::StmtExprClass:
1278  case Expr::ConvertVectorExprClass:
1279  case Expr::VAArgExprClass:
1280  return canSubStmtsThrow(*this, S);
1281 
1282  case Expr::CompoundLiteralExprClass:
1283  case Expr::CXXConstCastExprClass:
1284  case Expr::CXXReinterpretCastExprClass:
1285  case Expr::BuiltinBitCastExprClass:
1286  // FIXME: Properly determine whether a variably-modified type can throw.
1287  if (cast<Expr>(S)->getType()->isVariablyModifiedType())
1288  return CT_Can;
1289  return canSubStmtsThrow(*this, S);
1290 
1291  // Some might be dependent for other reasons.
1292  case Expr::ArraySubscriptExprClass:
1293  case Expr::OMPArraySectionExprClass:
1294  case Expr::BinaryOperatorClass:
1295  case Expr::DependentCoawaitExprClass:
1296  case Expr::CompoundAssignOperatorClass:
1297  case Expr::CStyleCastExprClass:
1298  case Expr::CXXStaticCastExprClass:
1299  case Expr::CXXFunctionalCastExprClass:
1300  case Expr::ImplicitCastExprClass:
1301  case Expr::MaterializeTemporaryExprClass:
1302  case Expr::UnaryOperatorClass: {
1303  // FIXME: Properly determine whether a variably-modified type can throw.
1304  if (auto *CE = dyn_cast<CastExpr>(S))
1305  if (CE->getType()->isVariablyModifiedType())
1306  return CT_Can;
1307  CanThrowResult CT =
1308  cast<Expr>(S)->isTypeDependent() ? CT_Dependent : CT_Cannot;
1309  return mergeCanThrow(CT, canSubStmtsThrow(*this, S));
1310  }
1311 
1312  case Expr::CXXDefaultArgExprClass:
1313  return canThrow(cast<CXXDefaultArgExpr>(S)->getExpr());
1314 
1315  case Expr::CXXDefaultInitExprClass:
1316  return canThrow(cast<CXXDefaultInitExpr>(S)->getExpr());
1317 
1318  case Expr::ChooseExprClass: {
1319  auto *CE = cast<ChooseExpr>(S);
1320  if (CE->isTypeDependent() || CE->isValueDependent())
1321  return CT_Dependent;
1322  return canThrow(CE->getChosenSubExpr());
1323  }
1324 
1325  case Expr::GenericSelectionExprClass:
1326  if (cast<GenericSelectionExpr>(S)->isResultDependent())
1327  return CT_Dependent;
1328  return canThrow(cast<GenericSelectionExpr>(S)->getResultExpr());
1329 
1330  // Some expressions are always dependent.
1331  case Expr::CXXDependentScopeMemberExprClass:
1332  case Expr::CXXUnresolvedConstructExprClass:
1333  case Expr::DependentScopeDeclRefExprClass:
1334  case Expr::CXXFoldExprClass:
1335  return CT_Dependent;
1336 
1337  case Expr::AsTypeExprClass:
1338  case Expr::BinaryConditionalOperatorClass:
1339  case Expr::BlockExprClass:
1340  case Expr::CUDAKernelCallExprClass:
1341  case Expr::DeclRefExprClass:
1342  case Expr::ObjCBridgedCastExprClass:
1343  case Expr::ObjCIndirectCopyRestoreExprClass:
1344  case Expr::ObjCProtocolExprClass:
1345  case Expr::ObjCSelectorExprClass:
1346  case Expr::ObjCAvailabilityCheckExprClass:
1347  case Expr::OffsetOfExprClass:
1348  case Expr::PackExpansionExprClass:
1349  case Expr::SubstNonTypeTemplateParmExprClass:
1350  case Expr::SubstNonTypeTemplateParmPackExprClass:
1351  case Expr::FunctionParmPackExprClass:
1352  case Expr::UnaryExprOrTypeTraitExprClass:
1353  case Expr::UnresolvedLookupExprClass:
1354  case Expr::UnresolvedMemberExprClass:
1355  case Expr::TypoExprClass:
1356  // FIXME: Many of the above can throw.
1357  return CT_Cannot;
1358 
1359  case Expr::AddrLabelExprClass:
1360  case Expr::ArrayTypeTraitExprClass:
1361  case Expr::AtomicExprClass:
1362  case Expr::TypeTraitExprClass:
1363  case Expr::CXXBoolLiteralExprClass:
1364  case Expr::CXXNoexceptExprClass:
1365  case Expr::CXXNullPtrLiteralExprClass:
1366  case Expr::CXXPseudoDestructorExprClass:
1367  case Expr::CXXScalarValueInitExprClass:
1368  case Expr::CXXThisExprClass:
1369  case Expr::CXXUuidofExprClass:
1370  case Expr::CharacterLiteralClass:
1371  case Expr::ExpressionTraitExprClass:
1372  case Expr::FloatingLiteralClass:
1373  case Expr::GNUNullExprClass:
1374  case Expr::ImaginaryLiteralClass:
1375  case Expr::ImplicitValueInitExprClass:
1376  case Expr::IntegerLiteralClass:
1377  case Expr::FixedPointLiteralClass:
1378  case Expr::ArrayInitIndexExprClass:
1379  case Expr::NoInitExprClass:
1380  case Expr::ObjCEncodeExprClass:
1381  case Expr::ObjCStringLiteralClass:
1382  case Expr::ObjCBoolLiteralExprClass:
1383  case Expr::OpaqueValueExprClass:
1384  case Expr::PredefinedExprClass:
1385  case Expr::SizeOfPackExprClass:
1386  case Expr::StringLiteralClass:
1387  case Expr::SourceLocExprClass:
1388  case Expr::ConceptSpecializationExprClass:
1389  case Expr::RequiresExprClass:
1390  // These expressions can never throw.
1391  return CT_Cannot;
1392 
1393  case Expr::MSPropertyRefExprClass:
1394  case Expr::MSPropertySubscriptExprClass:
1395  llvm_unreachable("Invalid class for expression");
1396 
1397  // Most statements can throw if any substatement can throw.
1398  case Stmt::AttributedStmtClass:
1399  case Stmt::BreakStmtClass:
1400  case Stmt::CapturedStmtClass:
1401  case Stmt::CaseStmtClass:
1402  case Stmt::CompoundStmtClass:
1403  case Stmt::ContinueStmtClass:
1404  case Stmt::CoreturnStmtClass:
1405  case Stmt::CoroutineBodyStmtClass:
1406  case Stmt::CXXCatchStmtClass:
1407  case Stmt::CXXForRangeStmtClass:
1408  case Stmt::DefaultStmtClass:
1409  case Stmt::DoStmtClass:
1410  case Stmt::ForStmtClass:
1411  case Stmt::GCCAsmStmtClass:
1412  case Stmt::GotoStmtClass:
1413  case Stmt::IndirectGotoStmtClass:
1414  case Stmt::LabelStmtClass:
1415  case Stmt::MSAsmStmtClass:
1416  case Stmt::MSDependentExistsStmtClass:
1417  case Stmt::NullStmtClass:
1418  case Stmt::ObjCAtCatchStmtClass:
1419  case Stmt::ObjCAtFinallyStmtClass:
1420  case Stmt::ObjCAtSynchronizedStmtClass:
1421  case Stmt::ObjCAutoreleasePoolStmtClass:
1422  case Stmt::ObjCForCollectionStmtClass:
1423  case Stmt::OMPAtomicDirectiveClass:
1424  case Stmt::OMPBarrierDirectiveClass:
1425  case Stmt::OMPCancelDirectiveClass:
1426  case Stmt::OMPCancellationPointDirectiveClass:
1427  case Stmt::OMPCriticalDirectiveClass:
1428  case Stmt::OMPDistributeDirectiveClass:
1429  case Stmt::OMPDistributeParallelForDirectiveClass:
1430  case Stmt::OMPDistributeParallelForSimdDirectiveClass:
1431  case Stmt::OMPDistributeSimdDirectiveClass:
1432  case Stmt::OMPFlushDirectiveClass:
1433  case Stmt::OMPForDirectiveClass:
1434  case Stmt::OMPForSimdDirectiveClass:
1435  case Stmt::OMPMasterDirectiveClass:
1436  case Stmt::OMPMasterTaskLoopDirectiveClass:
1437  case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
1438  case Stmt::OMPOrderedDirectiveClass:
1439  case Stmt::OMPParallelDirectiveClass:
1440  case Stmt::OMPParallelForDirectiveClass:
1441  case Stmt::OMPParallelForSimdDirectiveClass:
1442  case Stmt::OMPParallelMasterDirectiveClass:
1443  case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
1444  case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
1445  case Stmt::OMPParallelSectionsDirectiveClass:
1446  case Stmt::OMPSectionDirectiveClass:
1447  case Stmt::OMPSectionsDirectiveClass:
1448  case Stmt::OMPSimdDirectiveClass:
1449  case Stmt::OMPSingleDirectiveClass:
1450  case Stmt::OMPTargetDataDirectiveClass:
1451  case Stmt::OMPTargetDirectiveClass:
1452  case Stmt::OMPTargetEnterDataDirectiveClass:
1453  case Stmt::OMPTargetExitDataDirectiveClass:
1454  case Stmt::OMPTargetParallelDirectiveClass:
1455  case Stmt::OMPTargetParallelForDirectiveClass:
1456  case Stmt::OMPTargetParallelForSimdDirectiveClass:
1457  case Stmt::OMPTargetSimdDirectiveClass:
1458  case Stmt::OMPTargetTeamsDirectiveClass:
1459  case Stmt::OMPTargetTeamsDistributeDirectiveClass:
1460  case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
1461  case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
1462  case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
1463  case Stmt::OMPTargetUpdateDirectiveClass:
1464  case Stmt::OMPTaskDirectiveClass:
1465  case Stmt::OMPTaskgroupDirectiveClass:
1466  case Stmt::OMPTaskLoopDirectiveClass:
1467  case Stmt::OMPTaskLoopSimdDirectiveClass:
1468  case Stmt::OMPTaskwaitDirectiveClass:
1469  case Stmt::OMPTaskyieldDirectiveClass:
1470  case Stmt::OMPTeamsDirectiveClass:
1471  case Stmt::OMPTeamsDistributeDirectiveClass:
1472  case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
1473  case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
1474  case Stmt::OMPTeamsDistributeSimdDirectiveClass:
1475  case Stmt::ReturnStmtClass:
1476  case Stmt::SEHExceptStmtClass:
1477  case Stmt::SEHFinallyStmtClass:
1478  case Stmt::SEHLeaveStmtClass:
1479  case Stmt::SEHTryStmtClass:
1480  case Stmt::SwitchStmtClass:
1481  case Stmt::WhileStmtClass:
1482  return canSubStmtsThrow(*this, S);
1483 
1484  case Stmt::DeclStmtClass: {
1486  for (const Decl *D : cast<DeclStmt>(S)->decls()) {
1487  if (auto *VD = dyn_cast<VarDecl>(D))
1488  CT = mergeCanThrow(CT, canVarDeclThrow(*this, VD));
1489 
1490  // FIXME: Properly determine whether a variably-modified type can throw.
1491  if (auto *TND = dyn_cast<TypedefNameDecl>(D))
1492  if (TND->getUnderlyingType()->isVariablyModifiedType())
1493  return CT_Can;
1494  if (auto *VD = dyn_cast<ValueDecl>(D))
1495  if (VD->getType()->isVariablyModifiedType())
1496  return CT_Can;
1497  }
1498  return CT;
1499  }
1500 
1501  case Stmt::IfStmtClass: {
1502  auto *IS = cast<IfStmt>(S);
1504  if (const Stmt *Init = IS->getInit())
1505  CT = mergeCanThrow(CT, canThrow(Init));
1506  if (const Stmt *CondDS = IS->getConditionVariableDeclStmt())
1507  CT = mergeCanThrow(CT, canThrow(CondDS));
1508  CT = mergeCanThrow(CT, canThrow(IS->getCond()));
1509 
1510  // For 'if constexpr', consider only the non-discarded case.
1511  // FIXME: We should add a DiscardedStmt marker to the AST.
1512  if (Optional<const Stmt *> Case = IS->getNondiscardedCase(Context))
1513  return *Case ? mergeCanThrow(CT, canThrow(*Case)) : CT;
1514 
1515  CanThrowResult Then = canThrow(IS->getThen());
1516  CanThrowResult Else = IS->getElse() ? canThrow(IS->getElse()) : CT_Cannot;
1517  if (Then == Else)
1518  return mergeCanThrow(CT, Then);
1519 
1520  // For a dependent 'if constexpr', the result is dependent if it depends on
1521  // the value of the condition.
1522  return mergeCanThrow(CT, IS->isConstexpr() ? CT_Dependent
1523  : mergeCanThrow(Then, Else));
1524  }
1525 
1526  case Stmt::CXXTryStmtClass: {
1527  auto *TS = cast<CXXTryStmt>(S);
1528  // try /*...*/ catch (...) { H } can throw only if H can throw.
1529  // Any other try-catch can throw if any substatement can throw.
1530  const CXXCatchStmt *FinalHandler = TS->getHandler(TS->getNumHandlers() - 1);
1531  if (!FinalHandler->getExceptionDecl())
1532  return canThrow(FinalHandler->getHandlerBlock());
1533  return canSubStmtsThrow(*this, S);
1534  }
1535 
1536  case Stmt::ObjCAtThrowStmtClass:
1537  return CT_Can;
1538 
1539  case Stmt::ObjCAtTryStmtClass: {
1540  auto *TS = cast<ObjCAtTryStmt>(S);
1541 
1542  // @catch(...) need not be last in Objective-C. Walk backwards until we
1543  // see one or hit the @try.
1545  if (const Stmt *Finally = TS->getFinallyStmt())
1546  CT = mergeCanThrow(CT, canThrow(Finally));
1547  for (unsigned I = TS->getNumCatchStmts(); I != 0; --I) {
1548  const ObjCAtCatchStmt *Catch = TS->getCatchStmt(I - 1);
1549  CT = mergeCanThrow(CT, canThrow(Catch));
1550  // If we reach a @catch(...), no earlier exceptions can escape.
1551  if (Catch->hasEllipsis())
1552  return CT;
1553  }
1554 
1555  // Didn't find an @catch(...). Exceptions from the @try body can escape.
1556  return mergeCanThrow(CT, canThrow(TS->getTryBody()));
1557  }
1558 
1559  case Stmt::NoStmtClass:
1560  llvm_unreachable("Invalid class for statement");
1561  }
1562  llvm_unreachable("Bogus StmtClass");
1563 }
1564 
1565 } // end namespace clang
Represents a function declaration or definition.
Definition: Decl.h:1783
no exception specification
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
A (possibly-)qualified type.
Definition: Type.h:654
bool isArrayType() const
Definition: Type.h:6570
bool isMemberPointerType() const
Definition: Type.h:6552
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
unsigned getNumExceptions() const
Return the number of types in the exception specification.
Definition: Type.h:4032
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3075
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Stmt - This represents one statement.
Definition: Stmt.h:66
ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, ExceptionSpecificationType &EST)
Check the given noexcept-specifier, convert its expression, and compute the appropriate ExceptionSpec...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
Defines the SourceManager interface.
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:704
bool isRecordType() const
Definition: Type.h:6594
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:6764
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
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:386
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1931
Represent a C++ namespace.
Definition: Decl.h:497
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:49
A container of type source information.
Definition: Type.h:6227
Represents a variable declaration or definition.
Definition: Decl.h:820
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1792
unsigned getNumParams() const
Definition: Type.h:3964
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2487
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
Defines the Objective-C statement AST node classes.
Expr * getExprOperand() const
Definition: ExprCXX.h:821
Defines the clang::Expr interface and subclasses for C++ expressions.
noexcept(expression), value-dependent
The collection of all-type qualifiers we support.
Definition: Type.h:143
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
One of these records is kept for each identifier that is lexed.
bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const PartialDiagnostic &NoThrowDiagID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc)
CheckExceptionSpecSubset - Check whether the second function type&#39;s exception specification is a subs...
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
Definition: Sema.h:712
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2613
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:3971
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
bool isReferenceType() const
Definition: Type.h:6516
Expr * getSubExpr()
Definition: Expr.h:3202
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2984
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:764
PtrTy get() const
Definition: Ownership.h:170
static CanThrowResult canSubStmtsThrow(Sema &Self, const Stmt *S)
Microsoft throw(...) extension.
static CanThrowResult canVarDeclThrow(Sema &Self, const VarDecl *VD)
CanThrowResult canThrow(const Stmt *E)
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:1963
child_range children()
Definition: Stmt.cpp:224
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6326
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 EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)
Evaluate the implicit exception specification for a defaulted special member function.
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:1818
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
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:176
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1770
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:3173
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2172
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3360
bool hasAttr() const
Definition: DeclBase.h:542
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1690
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn&#39;t been determined yet (either because...
Definition: Type.h:4057
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2323
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:496
CanThrowResult mergeCanThrow(CanThrowResult CT1, CanThrowResult CT2)
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3375
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
This represents one expression.
Definition: Expr.h:108
QualType getPointeeType() const
Definition: Type.h:2771
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:88
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2649
Expr * getCallee()
Definition: Expr.h:2663
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool isNullPtrType() const
Definition: Type.h:6802
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:15007
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Definition: Expr.cpp:294
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7919
Defines the clang::TypeLoc interface and its subclasses.
QualType getType() const
Definition: Expr.h:137
bool handlerCanCatch(QualType HandlerType, QualType ExceptionType)
bool isInvalid() const
Definition: Ownership.h:166
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:1401
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6925
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:719
static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC)
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6315
RecordDecl * getDecl() const
Definition: Type.h:4505
noexcept(expression), evals to &#39;false&#39;
CanThrowResult
Possible results from evaluation of a noexcept expression.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:445
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3813
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1151
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3975
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:294
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3680
llvm::APSInt APSInt
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:3196
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3995
static bool hasImplicitExceptionSpec(FunctionDecl *Decl)
Determine whether a function has an implicitly-generated exception specification. ...
bool isStdNamespace() const
Definition: DeclBase.cpp:1075
static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC)
Represents a canonical, potentially-qualified type.
Definition: CanonicalType.h:65
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: Type.h:4047
bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)
Determine if we&#39;re in a case where we need to (incorrectly) eagerly parse an exception specification ...
static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D, SourceLocation Loc=SourceLocation())
Determine whether the callee of a particular function call can throw.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2345
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3989
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:4137
StringRef getName() const
Return the actual identifier string.
bool isTypeOperand() const
Definition: ExprCXX.h:804
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:21
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:453
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:3077
bool NE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:223
const Expr * getInit() const
Definition: Decl.h:1229
StmtClass getStmtClass() const
Definition: Stmt.h:1109
ArrayRef< QualType > exceptions() const
Definition: Type.h:4133
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2046
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:2833
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Definition: Type.h:3852
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2995
Pointer to a block type.
Definition: Type.h:2716
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:3098
bool hasEllipsis() const
Definition: StmtObjC.h:113
bool isFunctionType() const
Definition: Type.h:6500
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:700
CXXBasePath & front()
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Holds information about the various types of exception specification.
Definition: Type.h:3811
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:92
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:115
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1931
SourceManager & getSourceManager()
Definition: ASTContext.h:679
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
QualType getParamType(unsigned i) const
Definition: Type.h:3966
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
bool isVoidType() const
Definition: Type.h:6777
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
bool isPRValue() const
Definition: Expr.h:364
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:397
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:263
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2546
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.
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
Microsoft __declspec(nothrow) extension.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2150
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1975
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
Definition: ExprCXX.h:1949
bool isPointerType() const
Definition: Type.h:6504
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
static bool exceptionSpecNotKnownYet(const FunctionDecl *FD)
QualType getType() const
Definition: Decl.h:630
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:385
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
Definition: SemaExpr.cpp:17398
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:645
CanQualType BoolTy
Definition: ASTContext.h:1017
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
Decl * getCalleeDecl()
Definition: Expr.h:2675
void setType(QualType newType)
Definition: Decl.h:631
SourceLocation getBegin() const
static const FunctionProtoType * GetUnderlyingFunction(QualType T)
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
SourceLocation getLocation() const
Definition: DeclBase.h:429
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
noexcept(expression), evals to &#39;true&#39;
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2991