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