clang  10.0.0svn
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/TypeLoc.h"
19 #include "clang/Basic/Diagnostic.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallString.h"
23 
24 namespace clang {
25 
27 {
28  if (const PointerType *PtrTy = T->getAs<PointerType>())
29  T = PtrTy->getPointeeType();
30  else if (const ReferenceType *RefTy = T->getAs<ReferenceType>())
31  T = RefTy->getPointeeType();
32  else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
33  T = MPTy->getPointeeType();
34  return T->getAs<FunctionProtoType>();
35 }
36 
37 /// HACK: libstdc++ has a bug where it shadows std::swap with a member
38 /// swap function then tries to call std::swap unqualified from the exception
39 /// specification of that function. This function detects whether we're in
40 /// such a case and turns off delay-parsing of exception specifications.
42  auto *RD = dyn_cast<CXXRecordDecl>(CurContext);
43 
44  // All the problem cases are member functions named "swap" within class
45  // templates declared directly within namespace std or std::__debug or
46  // std::__profile.
47  if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
48  !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
49  return false;
50 
51  auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
52  if (!ND)
53  return false;
54 
55  bool IsInStd = ND->isStdNamespace();
56  if (!IsInStd) {
57  // This isn't a direct member of namespace std, but it might still be
58  // libstdc++'s std::__debug::array or std::__profile::array.
59  IdentifierInfo *II = ND->getIdentifier();
60  if (!II || !(II->isStr("__debug") || II->isStr("__profile")) ||
61  !ND->isInStdNamespace())
62  return false;
63  }
64 
65  // Only apply this hack within a system header.
67  return false;
68 
69  return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
70  .Case("array", true)
71  .Case("pair", IsInStd)
72  .Case("priority_queue", IsInStd)
73  .Case("stack", IsInStd)
74  .Case("queue", IsInStd)
75  .Default(false);
76 }
77 
79  Expr *NoexceptExpr,
81  // FIXME: This is bogus, a noexcept expression is not a condition.
82  ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr);
83  if (Converted.isInvalid())
84  return Converted;
85 
86  if (Converted.get()->isValueDependent()) {
88  return Converted;
89  }
90 
93  Converted.get(), &Result,
94  diag::err_noexcept_needs_constant_expression,
95  /*AllowFold*/ false);
96  if (!Converted.isInvalid())
97  EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue;
98  return Converted;
99 }
100 
101 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
102 /// exception specification. Incomplete types, or pointers to incomplete types
103 /// other than void are not allowed.
104 ///
105 /// \param[in,out] T The exception type. This will be decayed to a pointer type
106 /// when the input is an array or a function type.
108  // C++11 [except.spec]p2:
109  // A type cv T, "array of T", or "function returning T" denoted
110  // in an exception-specification is adjusted to type T, "pointer to T", or
111  // "pointer to function returning T", respectively.
112  //
113  // We also apply this rule in C++98.
114  if (T->isArrayType())
116  else if (T->isFunctionType())
117  T = Context.getPointerType(T);
118 
119  int Kind = 0;
120  QualType PointeeT = T;
121  if (const PointerType *PT = T->getAs<PointerType>()) {
122  PointeeT = PT->getPointeeType();
123  Kind = 1;
124 
125  // cv void* is explicitly permitted, despite being a pointer to an
126  // incomplete type.
127  if (PointeeT->isVoidType())
128  return false;
129  } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
130  PointeeT = RT->getPointeeType();
131  Kind = 2;
132 
133  if (RT->isRValueReferenceType()) {
134  // C++11 [except.spec]p2:
135  // A type denoted in an exception-specification shall not denote [...]
136  // an rvalue reference type.
137  Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
138  << T << Range;
139  return true;
140  }
141  }
142 
143  // C++11 [except.spec]p2:
144  // A type denoted in an exception-specification shall not denote an
145  // incomplete type other than a class currently being defined [...].
146  // A type denoted in an exception-specification shall not denote a
147  // pointer or reference to an incomplete type, other than (cv) void* or a
148  // pointer or reference to a class currently being defined.
149  // In Microsoft mode, downgrade this to a warning.
150  unsigned DiagID = diag::err_incomplete_in_exception_spec;
151  bool ReturnValueOnError = true;
152  if (getLangOpts().MSVCCompat) {
153  DiagID = diag::ext_incomplete_in_exception_spec;
154  ReturnValueOnError = false;
155  }
156  if (!(PointeeT->isRecordType() &&
157  PointeeT->castAs<RecordType>()->isBeingDefined()) &&
158  RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
159  return ReturnValueOnError;
160 
161  return false;
162 }
163 
164 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
165 /// to member to a function with an exception specification. This means that
166 /// it is invalid to add another level of indirection.
168  // C++17 removes this rule in favor of putting exception specifications into
169  // the type system.
170  if (getLangOpts().CPlusPlus17)
171  return false;
172 
173  if (const PointerType *PT = T->getAs<PointerType>())
174  T = PT->getPointeeType();
175  else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
176  T = PT->getPointeeType();
177  else
178  return false;
179 
180  const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
181  if (!FnT)
182  return false;
183 
184  return FnT->hasExceptionSpec();
185 }
186 
187 const FunctionProtoType *
189  if (FPT->getExceptionSpecType() == EST_Unparsed) {
190  Diag(Loc, diag::err_exception_spec_not_parsed);
191  return nullptr;
192  }
193 
195  return FPT;
196 
197  FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
198  const FunctionProtoType *SourceFPT =
199  SourceDecl->getType()->castAs<FunctionProtoType>();
200 
201  // If the exception specification has already been resolved, just return it.
203  return SourceFPT;
204 
205  // Compute or instantiate the exception specification now.
206  if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
207  EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl));
208  else
209  InstantiateExceptionSpec(Loc, SourceDecl);
210 
211  const FunctionProtoType *Proto =
212  SourceDecl->getType()->castAs<FunctionProtoType>();
213  if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
214  Diag(Loc, diag::err_exception_spec_not_parsed);
215  Proto = nullptr;
216  }
217  return Proto;
218 }
219 
220 void
223  // If we've fully resolved the exception specification, notify listeners.
225  if (auto *Listener = getASTMutationListener())
226  Listener->ResolvedExceptionSpec(FD);
227 
228  for (FunctionDecl *Redecl : FD->redecls())
229  Context.adjustExceptionSpec(Redecl, ESI);
230 }
231 
232 static bool exceptionSpecNotKnownYet(const FunctionDecl *FD) {
233  auto *MD = dyn_cast<CXXMethodDecl>(FD);
234  if (!MD)
235  return false;
236 
237  auto EST = MD->getType()->castAs<FunctionProtoType>()->getExceptionSpecType();
238  return EST == EST_Unparsed ||
239  (EST == EST_Unevaluated && MD->getParent()->isBeingDefined());
240 }
241 
243  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
244  const FunctionProtoType *Old, SourceLocation OldLoc,
245  const FunctionProtoType *New, SourceLocation NewLoc,
246  bool *MissingExceptionSpecification = nullptr,
247  bool *MissingEmptyExceptionSpecification = nullptr,
248  bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false);
249 
250 /// Determine whether a function has an implicitly-generated exception
251 /// specification.
253  if (!isa<CXXDestructorDecl>(Decl) &&
254  Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
255  Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
256  return false;
257 
258  // For a function that the user didn't declare:
259  // - if this is a destructor, its exception specification is implicit.
260  // - if this is 'operator delete' or 'operator delete[]', the exception
261  // specification is as-if an explicit exception specification was given
262  // (per [basic.stc.dynamic]p2).
263  if (!Decl->getTypeSourceInfo())
264  return isa<CXXDestructorDecl>(Decl);
265 
266  auto *Ty = Decl->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
267  return !Ty->hasExceptionSpec();
268 }
269 
271  // Just completely ignore this under -fno-exceptions prior to C++17.
272  // In C++17 onwards, the exception specification is part of the type and
273  // we will diagnose mismatches anyway, so it's better to check for them here.
274  if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17)
275  return false;
276 
278  bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
279  bool MissingExceptionSpecification = false;
280  bool MissingEmptyExceptionSpecification = false;
281 
282  unsigned DiagID = diag::err_mismatched_exception_spec;
283  bool ReturnValueOnError = true;
284  if (getLangOpts().MSVCCompat) {
285  DiagID = diag::ext_mismatched_exception_spec;
286  ReturnValueOnError = false;
287  }
288 
289  // If we're befriending a member function of a class that's currently being
290  // defined, we might not be able to work out its exception specification yet.
291  // If not, defer the check until later.
293  DelayedEquivalentExceptionSpecChecks.push_back({New, Old});
294  return false;
295  }
296 
297  // Check the types as written: they must match before any exception
298  // specification adjustment is applied.
300  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
301  Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
302  New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
303  &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
304  /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
305  // C++11 [except.spec]p4 [DR1492]:
306  // If a declaration of a function has an implicit
307  // exception-specification, other declarations of the function shall
308  // not specify an exception-specification.
309  if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions &&
311  Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
312  << hasImplicitExceptionSpec(Old);
313  if (Old->getLocation().isValid())
314  Diag(Old->getLocation(), diag::note_previous_declaration);
315  }
316  return false;
317  }
318 
319  // The failure was something other than an missing exception
320  // specification; return an error, except in MS mode where this is a warning.
321  if (!MissingExceptionSpecification)
322  return ReturnValueOnError;
323 
324  const FunctionProtoType *NewProto =
325  New->getType()->castAs<FunctionProtoType>();
326 
327  // The new function declaration is only missing an empty exception
328  // specification "throw()". If the throw() specification came from a
329  // function in a system header that has C linkage, just add an empty
330  // exception specification to the "new" declaration. Note that C library
331  // implementations are permitted to add these nothrow exception
332  // specifications.
333  //
334  // Likewise if the old function is a builtin.
335  if (MissingEmptyExceptionSpecification && NewProto &&
336  (Old->getLocation().isInvalid() ||
338  Old->getBuiltinID()) &&
339  Old->isExternC()) {
341  NewProto->getReturnType(), NewProto->getParamTypes(),
343  return false;
344  }
345 
346  const FunctionProtoType *OldProto =
347  Old->getType()->castAs<FunctionProtoType>();
348 
350  if (ESI.Type == EST_Dynamic) {
351  // FIXME: What if the exceptions are described in terms of the old
352  // prototype's parameters?
353  ESI.Exceptions = OldProto->exceptions();
354  }
355 
356  if (ESI.Type == EST_NoexceptFalse)
357  ESI.Type = EST_None;
358  if (ESI.Type == EST_NoexceptTrue)
359  ESI.Type = EST_BasicNoexcept;
360 
361  // For dependent noexcept, we can't just take the expression from the old
362  // prototype. It likely contains references to the old prototype's parameters.
363  if (ESI.Type == EST_DependentNoexcept) {
364  New->setInvalidDecl();
365  } else {
366  // Update the type of the function with the appropriate exception
367  // specification.
369  NewProto->getReturnType(), NewProto->getParamTypes(),
370  NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
371  }
372 
373  if (getLangOpts().MSVCCompat && ESI.Type != EST_DependentNoexcept) {
374  // Allow missing exception specifications in redeclarations as an extension.
375  DiagID = diag::ext_ms_missing_exception_specification;
376  ReturnValueOnError = false;
377  } else if (New->isReplaceableGlobalAllocationFunction() &&
378  ESI.Type != EST_DependentNoexcept) {
379  // Allow missing exception specifications in redeclarations as an extension,
380  // when declaring a replaceable global allocation function.
381  DiagID = diag::ext_missing_exception_specification;
382  ReturnValueOnError = false;
383  } else if (ESI.Type == EST_NoThrow) {
384  // Allow missing attribute 'nothrow' in redeclarations, since this is a very
385  // common omission.
386  DiagID = diag::ext_missing_exception_specification;
387  ReturnValueOnError = false;
388  } else {
389  DiagID = diag::err_missing_exception_specification;
390  ReturnValueOnError = true;
391  }
392 
393  // Warn about the lack of exception specification.
394  SmallString<128> ExceptionSpecString;
395  llvm::raw_svector_ostream OS(ExceptionSpecString);
396  switch (OldProto->getExceptionSpecType()) {
397  case EST_DynamicNone:
398  OS << "throw()";
399  break;
400 
401  case EST_Dynamic: {
402  OS << "throw(";
403  bool OnFirstException = true;
404  for (const auto &E : OldProto->exceptions()) {
405  if (OnFirstException)
406  OnFirstException = false;
407  else
408  OS << ", ";
409 
410  OS << E.getAsString(getPrintingPolicy());
411  }
412  OS << ")";
413  break;
414  }
415 
416  case EST_BasicNoexcept:
417  OS << "noexcept";
418  break;
419 
421  case EST_NoexceptFalse:
422  case EST_NoexceptTrue:
423  OS << "noexcept(";
424  assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
425  OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
426  OS << ")";
427  break;
428  case EST_NoThrow:
429  OS <<"__attribute__((nothrow))";
430  break;
431  case EST_None:
432  case EST_MSAny:
433  case EST_Unevaluated:
434  case EST_Uninstantiated:
435  case EST_Unparsed:
436  llvm_unreachable("This spec type is compatible with none.");
437  }
438 
439  SourceLocation FixItLoc;
440  if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
441  TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
442  // FIXME: Preserve enough information so that we can produce a correct fixit
443  // location when there is a trailing return type.
444  if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>())
445  if (!FTLoc.getTypePtr()->hasTrailingReturn())
446  FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
447  }
448 
449  if (FixItLoc.isInvalid())
450  Diag(New->getLocation(), DiagID)
451  << New << OS.str();
452  else {
453  Diag(New->getLocation(), DiagID)
454  << New << OS.str()
455  << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
456  }
457 
458  if (Old->getLocation().isValid())
459  Diag(Old->getLocation(), diag::note_previous_declaration);
460 
461  return ReturnValueOnError;
462 }
463 
464 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent
465 /// exception specifications. Exception specifications are equivalent if
466 /// they allow exactly the same set of exception types. It does not matter how
467 /// that is achieved. See C++ [except.spec]p2.
469  const FunctionProtoType *Old, SourceLocation OldLoc,
470  const FunctionProtoType *New, SourceLocation NewLoc) {
471  if (!getLangOpts().CXXExceptions)
472  return false;
473 
474  unsigned DiagID = diag::err_mismatched_exception_spec;
475  if (getLangOpts().MSVCCompat)
476  DiagID = diag::ext_mismatched_exception_spec;
478  *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
479  Old, OldLoc, New, NewLoc);
480 
481  // In Microsoft mode, mismatching exception specifications just cause a warning.
482  if (getLangOpts().MSVCCompat)
483  return false;
484  return Result;
485 }
486 
487 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
488 /// exception specifications. See C++ [except.spec]p3.
489 ///
490 /// \return \c false if the exception specifications match, \c true if there is
491 /// a problem. If \c true is returned, either a diagnostic has already been
492 /// produced or \c *MissingExceptionSpecification is set to \c true.
494  Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID,
495  const FunctionProtoType *Old, SourceLocation OldLoc,
496  const FunctionProtoType *New, SourceLocation NewLoc,
497  bool *MissingExceptionSpecification,
498  bool *MissingEmptyExceptionSpecification,
499  bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) {
500  if (MissingExceptionSpecification)
501  *MissingExceptionSpecification = false;
502 
503  if (MissingEmptyExceptionSpecification)
504  *MissingEmptyExceptionSpecification = false;
505 
506  Old = S.ResolveExceptionSpec(NewLoc, Old);
507  if (!Old)
508  return false;
509  New = S.ResolveExceptionSpec(NewLoc, New);
510  if (!New)
511  return false;
512 
513  // C++0x [except.spec]p3: Two exception-specifications are compatible if:
514  // - both are non-throwing, regardless of their form,
515  // - both have the form noexcept(constant-expression) and the constant-
516  // expressions are equivalent,
517  // - both are dynamic-exception-specifications that have the same set of
518  // adjusted types.
519  //
520  // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
521  // of the form throw(), noexcept, or noexcept(constant-expression) where the
522  // constant-expression yields true.
523  //
524  // C++0x [except.spec]p4: If any declaration of a function has an exception-
525  // specifier that is not a noexcept-specification allowing all exceptions,
526  // all declarations [...] of that function shall have a compatible
527  // exception-specification.
528  //
529  // That last point basically means that noexcept(false) matches no spec.
530  // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
531 
534 
535  assert(!isUnresolvedExceptionSpec(OldEST) &&
536  !isUnresolvedExceptionSpec(NewEST) &&
537  "Shouldn't see unknown exception specifications here");
538 
539  CanThrowResult OldCanThrow = Old->canThrow();
540  CanThrowResult NewCanThrow = New->canThrow();
541 
542  // Any non-throwing specifications are compatible.
543  if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot)
544  return false;
545 
546  // Any throws-anything specifications are usually compatible.
547  if (OldCanThrow == CT_Can && OldEST != EST_Dynamic &&
548  NewCanThrow == CT_Can && NewEST != EST_Dynamic) {
549  // The exception is that the absence of an exception specification only
550  // matches noexcept(false) for functions, as described above.
551  if (!AllowNoexceptAllMatchWithNoSpec &&
552  ((OldEST == EST_None && NewEST == EST_NoexceptFalse) ||
553  (OldEST == EST_NoexceptFalse && NewEST == EST_None))) {
554  // This is the disallowed case.
555  } else {
556  return false;
557  }
558  }
559 
560  // C++14 [except.spec]p3:
561  // Two exception-specifications are compatible if [...] both have the form
562  // noexcept(constant-expression) and the constant-expressions are equivalent
563  if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) {
564  llvm::FoldingSetNodeID OldFSN, NewFSN;
565  Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true);
566  New->getNoexceptExpr()->Profile(NewFSN, S.Context, true);
567  if (OldFSN == NewFSN)
568  return false;
569  }
570 
571  // Dynamic exception specifications with the same set of adjusted types
572  // are compatible.
573  if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) {
574  bool Success = true;
575  // Both have a dynamic exception spec. Collect the first set, then compare
576  // to the second.
577  llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
578  for (const auto &I : Old->exceptions())
579  OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
580 
581  for (const auto &I : New->exceptions()) {
583  if (OldTypes.count(TypePtr))
584  NewTypes.insert(TypePtr);
585  else {
586  Success = false;
587  break;
588  }
589  }
590 
591  if (Success && OldTypes.size() == NewTypes.size())
592  return false;
593  }
594 
595  // As a special compatibility feature, under C++0x we accept no spec and
596  // throw(std::bad_alloc) as equivalent for operator new and operator new[].
597  // This is because the implicit declaration changed, but old code would break.
598  if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) {
599  const FunctionProtoType *WithExceptions = nullptr;
600  if (OldEST == EST_None && NewEST == EST_Dynamic)
601  WithExceptions = New;
602  else if (OldEST == EST_Dynamic && NewEST == EST_None)
603  WithExceptions = Old;
604  if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
605  // One has no spec, the other throw(something). If that something is
606  // std::bad_alloc, all conditions are met.
607  QualType Exception = *WithExceptions->exception_begin();
608  if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
609  IdentifierInfo* Name = ExRecord->getIdentifier();
610  if (Name && Name->getName() == "bad_alloc") {
611  // It's called bad_alloc, but is it in std?
612  if (ExRecord->isInStdNamespace()) {
613  return false;
614  }
615  }
616  }
617  }
618  }
619 
620  // If the caller wants to handle the case that the new function is
621  // incompatible due to a missing exception specification, let it.
622  if (MissingExceptionSpecification && OldEST != EST_None &&
623  NewEST == EST_None) {
624  // The old type has an exception specification of some sort, but
625  // the new type does not.
626  *MissingExceptionSpecification = true;
627 
628  if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) {
629  // The old type has a throw() or noexcept(true) exception specification
630  // and the new type has no exception specification, and the caller asked
631  // to handle this itself.
632  *MissingEmptyExceptionSpecification = true;
633  }
634 
635  return true;
636  }
637 
638  S.Diag(NewLoc, DiagID);
639  if (NoteID.getDiagID() != 0 && OldLoc.isValid())
640  S.Diag(OldLoc, NoteID);
641  return true;
642 }
643 
645  const PartialDiagnostic &NoteID,
646  const FunctionProtoType *Old,
647  SourceLocation OldLoc,
648  const FunctionProtoType *New,
649  SourceLocation NewLoc) {
650  if (!getLangOpts().CXXExceptions)
651  return false;
652  return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc,
653  New, NewLoc);
654 }
655 
656 bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) {
657  // [except.handle]p3:
658  // A handler is a match for an exception object of type E if:
659 
660  // HandlerType must be ExceptionType or derived from it, or pointer or
661  // reference to such types.
662  const ReferenceType *RefTy = HandlerType->getAs<ReferenceType>();
663  if (RefTy)
664  HandlerType = RefTy->getPointeeType();
665 
666  // -- the handler is of type cv T or cv T& and E and T are the same type
667  if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType))
668  return true;
669 
670  // FIXME: ObjC pointer types?
671  if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) {
672  if (RefTy && (!HandlerType.isConstQualified() ||
673  HandlerType.isVolatileQualified()))
674  return false;
675 
676  // -- the handler is of type cv T or const T& where T is a pointer or
677  // pointer to member type and E is std::nullptr_t
678  if (ExceptionType->isNullPtrType())
679  return true;
680 
681  // -- the handler is of type cv T or const T& where T is a pointer or
682  // pointer to member type and E is a pointer or pointer to member type
683  // that can be converted to T by one or more of
684  // -- a qualification conversion
685  // -- a function pointer conversion
686  bool LifetimeConv;
688  // FIXME: Should we treat the exception as catchable if a lifetime
689  // conversion is required?
690  if (IsQualificationConversion(ExceptionType, HandlerType, false,
691  LifetimeConv) ||
692  IsFunctionConversion(ExceptionType, HandlerType, Result))
693  return true;
694 
695  // -- a standard pointer conversion [...]
696  if (!ExceptionType->isPointerType() || !HandlerType->isPointerType())
697  return false;
698 
699  // Handle the "qualification conversion" portion.
700  Qualifiers EQuals, HQuals;
701  ExceptionType = Context.getUnqualifiedArrayType(
702  ExceptionType->getPointeeType(), EQuals);
703  HandlerType = Context.getUnqualifiedArrayType(
704  HandlerType->getPointeeType(), HQuals);
705  if (!HQuals.compatiblyIncludes(EQuals))
706  return false;
707 
708  if (HandlerType->isVoidType() && ExceptionType->isObjectType())
709  return true;
710 
711  // The only remaining case is a derived-to-base conversion.
712  }
713 
714  // -- the handler is of type cg T or cv T& and T is an unambiguous public
715  // base class of E
716  if (!ExceptionType->isRecordType() || !HandlerType->isRecordType())
717  return false;
718  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
719  /*DetectVirtual=*/false);
720  if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) ||
721  Paths.isAmbiguous(Context.getCanonicalType(HandlerType)))
722  return false;
723 
724  // Do this check from a context without privileges.
725  switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType,
726  Paths.front(),
727  /*Diagnostic*/ 0,
728  /*ForceCheck*/ true,
729  /*ForceUnprivileged*/ true)) {
730  case AR_accessible: return true;
731  case AR_inaccessible: return false;
732  case AR_dependent:
733  llvm_unreachable("access check dependent for unprivileged context");
734  case AR_delayed:
735  llvm_unreachable("access check delayed in non-declaration");
736  }
737  llvm_unreachable("unexpected access check result");
738 }
739 
740 /// CheckExceptionSpecSubset - Check whether the second function type's
741 /// exception specification is a subset (or equivalent) of the first function
742 /// type. This is used by override and pointer assignment checks.
744  const PartialDiagnostic &NestedDiagID,
745  const PartialDiagnostic &NoteID,
746  const PartialDiagnostic &NoThrowDiagID,
747  const FunctionProtoType *Superset,
748  SourceLocation SuperLoc,
749  const FunctionProtoType *Subset,
750  SourceLocation SubLoc) {
751 
752  // Just auto-succeed under -fno-exceptions.
753  if (!getLangOpts().CXXExceptions)
754  return false;
755 
756  // FIXME: As usual, we could be more specific in our error messages, but
757  // that better waits until we've got types with source locations.
758 
759  if (!SubLoc.isValid())
760  SubLoc = SuperLoc;
761 
762  // Resolve the exception specifications, if needed.
763  Superset = ResolveExceptionSpec(SuperLoc, Superset);
764  if (!Superset)
765  return false;
766  Subset = ResolveExceptionSpec(SubLoc, Subset);
767  if (!Subset)
768  return false;
769 
770  ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
772  assert(!isUnresolvedExceptionSpec(SuperEST) &&
773  !isUnresolvedExceptionSpec(SubEST) &&
774  "Shouldn't see unknown exception specifications here");
775 
776  // If there are dependent noexcept specs, assume everything is fine. Unlike
777  // with the equivalency check, this is safe in this case, because we don't
778  // want to merge declarations. Checks after instantiation will catch any
779  // omissions we make here.
780  if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept)
781  return false;
782 
783  CanThrowResult SuperCanThrow = Superset->canThrow();
784  CanThrowResult SubCanThrow = Subset->canThrow();
785 
786  // If the superset contains everything or the subset contains nothing, we're
787  // done.
788  if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) ||
789  SubCanThrow == CT_Cannot)
790  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
791  Subset, SubLoc);
792 
793  // Allow __declspec(nothrow) to be missing on redeclaration as an extension in
794  // some cases.
795  if (NoThrowDiagID.getDiagID() != 0 && SubCanThrow == CT_Can &&
796  SuperCanThrow == CT_Cannot && SuperEST == EST_NoThrow) {
797  Diag(SubLoc, NoThrowDiagID);
798  if (NoteID.getDiagID() != 0)
799  Diag(SuperLoc, NoteID);
800  return true;
801  }
802 
803  // If the subset contains everything or the superset contains nothing, we've
804  // failed.
805  if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) ||
806  SuperCanThrow == CT_Cannot) {
807  Diag(SubLoc, DiagID);
808  if (NoteID.getDiagID() != 0)
809  Diag(SuperLoc, NoteID);
810  return true;
811  }
812 
813  assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
814  "Exception spec subset: non-dynamic case slipped through.");
815 
816  // Neither contains everything or nothing. Do a proper comparison.
817  for (QualType SubI : Subset->exceptions()) {
818  if (const ReferenceType *RefTy = SubI->getAs<ReferenceType>())
819  SubI = RefTy->getPointeeType();
820 
821  // Make sure it's in the superset.
822  bool Contained = false;
823  for (QualType SuperI : Superset->exceptions()) {
824  // [except.spec]p5:
825  // the target entity shall allow at least the exceptions allowed by the
826  // source
827  //
828  // We interpret this as meaning that a handler for some target type would
829  // catch an exception of each source type.
830  if (handlerCanCatch(SuperI, SubI)) {
831  Contained = true;
832  break;
833  }
834  }
835  if (!Contained) {
836  Diag(SubLoc, DiagID);
837  if (NoteID.getDiagID() != 0)
838  Diag(SuperLoc, NoteID);
839  return true;
840  }
841  }
842  // We've run half the gauntlet.
843  return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
844  Subset, SubLoc);
845 }
846 
847 static bool
849  const PartialDiagnostic &NoteID, QualType Target,
850  SourceLocation TargetLoc, QualType Source,
851  SourceLocation SourceLoc) {
852  const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
853  if (!TFunc)
854  return false;
855  const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
856  if (!SFunc)
857  return false;
858 
859  return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
860  SFunc, SourceLoc);
861 }
862 
863 /// CheckParamExceptionSpec - Check if the parameter and return types of the
864 /// two functions have equivalent exception specs. This is part of the
865 /// assignment and override compatibility check. We do not check the parameters
866 /// of parameter function pointers recursively, as no sane programmer would
867 /// even be able to write such a function type.
869  const PartialDiagnostic &NoteID,
870  const FunctionProtoType *Target,
871  SourceLocation TargetLoc,
872  const FunctionProtoType *Source,
873  SourceLocation SourceLoc) {
874  auto RetDiag = DiagID;
875  RetDiag << 0;
877  *this, RetDiag, PDiag(),
878  Target->getReturnType(), TargetLoc, Source->getReturnType(),
879  SourceLoc))
880  return true;
881 
882  // We shouldn't even be testing this unless the arguments are otherwise
883  // compatible.
884  assert(Target->getNumParams() == Source->getNumParams() &&
885  "Functions have different argument counts.");
886  for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
887  auto ParamDiag = DiagID;
888  ParamDiag << 1;
890  *this, ParamDiag, PDiag(),
891  Target->getParamType(i), TargetLoc, Source->getParamType(i),
892  SourceLoc))
893  return true;
894  }
895  return false;
896 }
897 
899  // First we check for applicability.
900  // Target type must be a function, function pointer or function reference.
901  const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
902  if (!ToFunc || ToFunc->hasDependentExceptionSpec())
903  return false;
904 
905  // SourceType must be a function or function pointer.
906  const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
907  if (!FromFunc || FromFunc->hasDependentExceptionSpec())
908  return false;
909 
910  unsigned DiagID = diag::err_incompatible_exception_specs;
911  unsigned NestedDiagID = diag::err_deep_exception_specs_differ;
912  // This is not an error in C++17 onwards, unless the noexceptness doesn't
913  // match, but in that case we have a full-on type mismatch, not just a
914  // type sugar mismatch.
915  if (getLangOpts().CPlusPlus17) {
916  DiagID = diag::warn_incompatible_exception_specs;
917  NestedDiagID = diag::warn_deep_exception_specs_differ;
918  }
919 
920  // Now we've got the correct types on both sides, check their compatibility.
921  // This means that the source of the conversion can only throw a subset of
922  // the exceptions of the target, and any exception specs on arguments or
923  // return types must be equivalent.
924  //
925  // FIXME: If there is a nested dependent exception specification, we should
926  // not be checking it here. This is fine:
927  // template<typename T> void f() {
928  // void (*p)(void (*) throw(T));
929  // void (*q)(void (*) throw(int)) = p;
930  // }
931  // ... because it might be instantiated with T=int.
933  PDiag(DiagID), PDiag(NestedDiagID), PDiag(), PDiag(), ToFunc,
934  From->getSourceRange().getBegin(), FromFunc, SourceLocation()) &&
935  !getLangOpts().CPlusPlus17;
936 }
937 
939  const CXXMethodDecl *Old) {
940  // If the new exception specification hasn't been parsed yet, skip the check.
941  // We'll get called again once it's been parsed.
942  if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
943  EST_Unparsed)
944  return false;
945 
946  // Don't check uninstantiated template destructors at all. We can only
947  // synthesize correct specs after the template is instantiated.
948  if (isa<CXXDestructorDecl>(New) && New->getParent()->isDependentType())
949  return false;
950 
951  // If the old exception specification hasn't been parsed yet, or the new
952  // exception specification can't be computed yet, remember that we need to
953  // perform this check when we get to the end of the outermost
954  // lexically-surrounding class.
956  DelayedOverridingExceptionSpecChecks.push_back({New, Old});
957  return false;
958  }
959 
960  unsigned DiagID = diag::err_override_exception_spec;
961  if (getLangOpts().MSVCCompat)
962  DiagID = diag::ext_override_exception_spec;
963  return CheckExceptionSpecSubset(PDiag(DiagID),
964  PDiag(diag::err_deep_exception_specs_differ),
965  PDiag(diag::note_overridden_virtual_function),
966  PDiag(diag::ext_override_exception_spec),
967  Old->getType()->castAs<FunctionProtoType>(),
968  Old->getLocation(),
969  New->getType()->castAs<FunctionProtoType>(),
970  New->getLocation());
971 }
972 
973 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) {
975  for (const Stmt *SubStmt : E->children()) {
976  R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
977  if (R == CT_Can)
978  break;
979  }
980  return R;
981 }
982 
983 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
984  // As an extension, we assume that __attribute__((nothrow)) functions don't
985  // throw.
986  if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
987  return CT_Cannot;
988 
989  QualType T;
990 
991  // In C++1z, just look at the function type of the callee.
992  if (S.getLangOpts().CPlusPlus17 && isa<CallExpr>(E)) {
993  E = cast<CallExpr>(E)->getCallee();
994  T = E->getType();
995  if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
996  // Sadly we don't preserve the actual type as part of the "bound member"
997  // placeholder, so we need to reconstruct it.
998  E = E->IgnoreParenImpCasts();
999 
1000  // Could be a call to a pointer-to-member or a plain member access.
1001  if (auto *Op = dyn_cast<BinaryOperator>(E)) {
1002  assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
1003  T = Op->getRHS()->getType()
1004  ->castAs<MemberPointerType>()->getPointeeType();
1005  } else {
1006  T = cast<MemberExpr>(E)->getMemberDecl()->getType();
1007  }
1008  }
1009  } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
1010  T = VD->getType();
1011  else
1012  // If we have no clue what we're calling, assume the worst.
1013  return CT_Can;
1014 
1015  const FunctionProtoType *FT;
1016  if ((FT = T->getAs<FunctionProtoType>())) {
1017  } else if (const PointerType *PT = T->getAs<PointerType>())
1018  FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1019  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1020  FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1021  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1022  FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1023  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1024  FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1025 
1026  if (!FT)
1027  return CT_Can;
1028 
1029  FT = S.ResolveExceptionSpec(E->getBeginLoc(), FT);
1030  if (!FT)
1031  return CT_Can;
1032 
1033  return FT->canThrow();
1034 }
1035 
1037  if (DC->isTypeDependent())
1038  return CT_Dependent;
1039 
1040  if (!DC->getTypeAsWritten()->isReferenceType())
1041  return CT_Cannot;
1042 
1043  if (DC->getSubExpr()->isTypeDependent())
1044  return CT_Dependent;
1045 
1046  return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
1047 }
1048 
1050  if (DC->isTypeOperand())
1051  return CT_Cannot;
1052 
1053  Expr *Op = DC->getExprOperand();
1054  if (Op->isTypeDependent())
1055  return CT_Dependent;
1056 
1057  const RecordType *RT = Op->getType()->getAs<RecordType>();
1058  if (!RT)
1059  return CT_Cannot;
1060 
1061  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1062  return CT_Cannot;
1063 
1064  if (Op->Classify(S.Context).isPRValue())
1065  return CT_Cannot;
1066 
1067  return CT_Can;
1068 }
1069 
1071  // C++ [expr.unary.noexcept]p3:
1072  // [Can throw] if in a potentially-evaluated context the expression would
1073  // contain:
1074  switch (E->getStmtClass()) {
1075  case Expr::ConstantExprClass:
1076  return canThrow(cast<ConstantExpr>(E)->getSubExpr());
1077 
1078  case Expr::CXXThrowExprClass:
1079  // - a potentially evaluated throw-expression
1080  return CT_Can;
1081 
1082  case Expr::CXXDynamicCastExprClass: {
1083  // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1084  // where T is a reference type, that requires a run-time check
1085  CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E));
1086  if (CT == CT_Can)
1087  return CT;
1088  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1089  }
1090 
1091  case Expr::CXXTypeidExprClass:
1092  // - a potentially evaluated typeid expression applied to a glvalue
1093  // expression whose type is a polymorphic class type
1094  return canTypeidThrow(*this, cast<CXXTypeidExpr>(E));
1095 
1096  // - a potentially evaluated call to a function, member function, function
1097  // pointer, or member function pointer that does not have a non-throwing
1098  // exception-specification
1099  case Expr::CallExprClass:
1100  case Expr::CXXMemberCallExprClass:
1101  case Expr::CXXOperatorCallExprClass:
1102  case Expr::UserDefinedLiteralClass: {
1103  const CallExpr *CE = cast<CallExpr>(E);
1104  CanThrowResult CT;
1105  if (E->isTypeDependent())
1106  CT = CT_Dependent;
1107  else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1108  CT = CT_Cannot;
1109  else
1110  CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
1111  if (CT == CT_Can)
1112  return CT;
1113  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1114  }
1115 
1116  case Expr::CXXConstructExprClass:
1117  case Expr::CXXTemporaryObjectExprClass: {
1118  CanThrowResult CT = canCalleeThrow(*this, E,
1119  cast<CXXConstructExpr>(E)->getConstructor());
1120  if (CT == CT_Can)
1121  return CT;
1122  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1123  }
1124 
1125  case Expr::CXXInheritedCtorInitExprClass:
1126  return canCalleeThrow(*this, E,
1127  cast<CXXInheritedCtorInitExpr>(E)->getConstructor());
1128 
1129  case Expr::LambdaExprClass: {
1130  const LambdaExpr *Lambda = cast<LambdaExpr>(E);
1133  Cap = Lambda->capture_init_begin(),
1134  CapEnd = Lambda->capture_init_end();
1135  Cap != CapEnd; ++Cap)
1136  CT = mergeCanThrow(CT, canThrow(*Cap));
1137  return CT;
1138  }
1139 
1140  case Expr::CXXNewExprClass: {
1141  CanThrowResult CT;
1142  if (E->isTypeDependent())
1143  CT = CT_Dependent;
1144  else
1145  CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew());
1146  if (CT == CT_Can)
1147  return CT;
1148  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1149  }
1150 
1151  case Expr::CXXDeleteExprClass: {
1152  CanThrowResult CT;
1153  QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType();
1154  if (DTy.isNull() || DTy->isDependentType()) {
1155  CT = CT_Dependent;
1156  } else {
1157  CT = canCalleeThrow(*this, E,
1158  cast<CXXDeleteExpr>(E)->getOperatorDelete());
1159  if (const RecordType *RT = DTy->getAs<RecordType>()) {
1160  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1161  const CXXDestructorDecl *DD = RD->getDestructor();
1162  if (DD)
1163  CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD));
1164  }
1165  if (CT == CT_Can)
1166  return CT;
1167  }
1168  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1169  }
1170 
1171  case Expr::CXXBindTemporaryExprClass: {
1172  // The bound temporary has to be destroyed again, which might throw.
1173  CanThrowResult CT = canCalleeThrow(*this, E,
1174  cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor());
1175  if (CT == CT_Can)
1176  return CT;
1177  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1178  }
1179 
1180  // ObjC message sends are like function calls, but never have exception
1181  // specs.
1182  case Expr::ObjCMessageExprClass:
1183  case Expr::ObjCPropertyRefExprClass:
1184  case Expr::ObjCSubscriptRefExprClass:
1185  return CT_Can;
1186 
1187  // All the ObjC literals that are implemented as calls are
1188  // potentially throwing unless we decide to close off that
1189  // possibility.
1190  case Expr::ObjCArrayLiteralClass:
1191  case Expr::ObjCDictionaryLiteralClass:
1192  case Expr::ObjCBoxedExprClass:
1193  return CT_Can;
1194 
1195  // Many other things have subexpressions, so we have to test those.
1196  // Some are simple:
1197  case Expr::CoawaitExprClass:
1198  case Expr::ConditionalOperatorClass:
1199  case Expr::CompoundLiteralExprClass:
1200  case Expr::CoyieldExprClass:
1201  case Expr::CXXConstCastExprClass:
1202  case Expr::CXXReinterpretCastExprClass:
1203  case Expr::CXXRewrittenBinaryOperatorClass:
1204  case Expr::BuiltinBitCastExprClass:
1205  case Expr::CXXStdInitializerListExprClass:
1206  case Expr::DesignatedInitExprClass:
1207  case Expr::DesignatedInitUpdateExprClass:
1208  case Expr::ExprWithCleanupsClass:
1209  case Expr::ExtVectorElementExprClass:
1210  case Expr::InitListExprClass:
1211  case Expr::ArrayInitLoopExprClass:
1212  case Expr::MemberExprClass:
1213  case Expr::ObjCIsaExprClass:
1214  case Expr::ObjCIvarRefExprClass:
1215  case Expr::ParenExprClass:
1216  case Expr::ParenListExprClass:
1217  case Expr::ShuffleVectorExprClass:
1218  case Expr::ConvertVectorExprClass:
1219  case Expr::VAArgExprClass:
1220  return canSubExprsThrow(*this, E);
1221 
1222  // Some might be dependent for other reasons.
1223  case Expr::ArraySubscriptExprClass:
1224  case Expr::OMPArraySectionExprClass:
1225  case Expr::BinaryOperatorClass:
1226  case Expr::DependentCoawaitExprClass:
1227  case Expr::CompoundAssignOperatorClass:
1228  case Expr::CStyleCastExprClass:
1229  case Expr::CXXStaticCastExprClass:
1230  case Expr::CXXFunctionalCastExprClass:
1231  case Expr::ImplicitCastExprClass:
1232  case Expr::MaterializeTemporaryExprClass:
1233  case Expr::UnaryOperatorClass: {
1235  return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1236  }
1237 
1238  // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1239  case Expr::StmtExprClass:
1240  return CT_Can;
1241 
1242  case Expr::CXXDefaultArgExprClass:
1243  return canThrow(cast<CXXDefaultArgExpr>(E)->getExpr());
1244 
1245  case Expr::CXXDefaultInitExprClass:
1246  return canThrow(cast<CXXDefaultInitExpr>(E)->getExpr());
1247 
1248  case Expr::ChooseExprClass:
1249  if (E->isTypeDependent() || E->isValueDependent())
1250  return CT_Dependent;
1251  return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr());
1252 
1253  case Expr::GenericSelectionExprClass:
1254  if (cast<GenericSelectionExpr>(E)->isResultDependent())
1255  return CT_Dependent;
1256  return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr());
1257 
1258  // Some expressions are always dependent.
1259  case Expr::CXXDependentScopeMemberExprClass:
1260  case Expr::CXXUnresolvedConstructExprClass:
1261  case Expr::DependentScopeDeclRefExprClass:
1262  case Expr::CXXFoldExprClass:
1263  return CT_Dependent;
1264 
1265  case Expr::AsTypeExprClass:
1266  case Expr::BinaryConditionalOperatorClass:
1267  case Expr::BlockExprClass:
1268  case Expr::CUDAKernelCallExprClass:
1269  case Expr::DeclRefExprClass:
1270  case Expr::ObjCBridgedCastExprClass:
1271  case Expr::ObjCIndirectCopyRestoreExprClass:
1272  case Expr::ObjCProtocolExprClass:
1273  case Expr::ObjCSelectorExprClass:
1274  case Expr::ObjCAvailabilityCheckExprClass:
1275  case Expr::OffsetOfExprClass:
1276  case Expr::PackExpansionExprClass:
1277  case Expr::PseudoObjectExprClass:
1278  case Expr::SubstNonTypeTemplateParmExprClass:
1279  case Expr::SubstNonTypeTemplateParmPackExprClass:
1280  case Expr::FunctionParmPackExprClass:
1281  case Expr::UnaryExprOrTypeTraitExprClass:
1282  case Expr::UnresolvedLookupExprClass:
1283  case Expr::UnresolvedMemberExprClass:
1284  case Expr::TypoExprClass:
1285  // FIXME: Can any of the above throw? If so, when?
1286  return CT_Cannot;
1287 
1288  case Expr::AddrLabelExprClass:
1289  case Expr::ArrayTypeTraitExprClass:
1290  case Expr::AtomicExprClass:
1291  case Expr::TypeTraitExprClass:
1292  case Expr::CXXBoolLiteralExprClass:
1293  case Expr::CXXNoexceptExprClass:
1294  case Expr::CXXNullPtrLiteralExprClass:
1295  case Expr::CXXPseudoDestructorExprClass:
1296  case Expr::CXXScalarValueInitExprClass:
1297  case Expr::CXXThisExprClass:
1298  case Expr::CXXUuidofExprClass:
1299  case Expr::CharacterLiteralClass:
1300  case Expr::ExpressionTraitExprClass:
1301  case Expr::FloatingLiteralClass:
1302  case Expr::GNUNullExprClass:
1303  case Expr::ImaginaryLiteralClass:
1304  case Expr::ImplicitValueInitExprClass:
1305  case Expr::IntegerLiteralClass:
1306  case Expr::FixedPointLiteralClass:
1307  case Expr::ArrayInitIndexExprClass:
1308  case Expr::NoInitExprClass:
1309  case Expr::ObjCEncodeExprClass:
1310  case Expr::ObjCStringLiteralClass:
1311  case Expr::ObjCBoolLiteralExprClass:
1312  case Expr::OpaqueValueExprClass:
1313  case Expr::PredefinedExprClass:
1314  case Expr::SizeOfPackExprClass:
1315  case Expr::StringLiteralClass:
1316  case Expr::SourceLocExprClass:
1317  case Expr::ConceptSpecializationExprClass:
1318  // These expressions can never throw.
1319  return CT_Cannot;
1320 
1321  case Expr::MSPropertyRefExprClass:
1322  case Expr::MSPropertySubscriptExprClass:
1323  llvm_unreachable("Invalid class for expression");
1324 
1325 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:
1326 #define STMT_RANGE(Base, First, Last)
1327 #define LAST_STMT_RANGE(BASE, FIRST, LAST)
1328 #define EXPR(CLASS, PARENT)
1329 #define ABSTRACT_STMT(STMT)
1330 #include "clang/AST/StmtNodes.inc"
1331  case Expr::NoStmtClass:
1332  llvm_unreachable("Invalid class for expression");
1333  }
1334  llvm_unreachable("Bogus StmtClass");
1335 }
1336 
1337 } // end namespace clang
CanThrowResult canThrow(const Expr *E)
Represents a function declaration or definition.
Definition: Decl.h:1784
no exception specification
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2585
A (possibly-)qualified type.
Definition: Type.h:643
bool isArrayType() const
Definition: Type.h:6447
bool isMemberPointerType() const
Definition: Type.h:6429
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:3987
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3019
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:686
bool isRecordType() const
Definition: Type.h:6471
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:6637
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1375
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...
void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Evaluate the implicit exception specification for a defaulted special member function.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1900
Represent a C++ namespace.
Definition: Decl.h:522
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:49
A container of type source information.
Definition: Decl.h:86
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:1775
unsigned getNumParams() const
Definition: Type.h:3927
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6858
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2422
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
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:137
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
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:694
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:3934
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:274
bool isReferenceType() const
Definition: Type.h:6403
Expr * getSubExpr()
Definition: Expr.h:3177
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2936
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
Microsoft throw(...) extension.
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec...
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1963
child_range children()
Definition: Stmt.cpp:223
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:6218
static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc)
Defines the Diagnostic-related interfaces.
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:1288
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:1765
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:3117
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2137
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3335
bool hasAttr() const
Definition: DeclBase.h:542
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:331
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1692
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn&#39;t been determined yet (either because...
Definition: Type.h:4012
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3725
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:487
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:3289
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:644
This represents one expression.
Definition: Expr.h:108
QualType getPointeeType() const
Definition: Type.h:2742
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:6923
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2629
Expr * getCallee()
Definition: Expr.h:2638
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool isNullPtrType() const
Definition: Type.h:6675
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:14881
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7826
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:1387
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:708
static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC)
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6207
RecordDecl * getDecl() const
Definition: Type.h:4454
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:3781
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1162
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3938
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:3651
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:3171
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1905
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3967
static bool hasImplicitExceptionSpec(FunctionDecl *Decl)
Determine whether a function has an implicitly-generated exception specification. ...
bool isStdNamespace() const
Definition: DeclBase.cpp:1073
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:4002
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
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:2329
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3961
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:4087
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:427
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:3074
StmtClass getStmtClass() const
Definition: Stmt.h:1097
ArrayRef< QualType > exceptions() const
Definition: Type.h:4083
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2028
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:2804
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Definition: Type.h:3819
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2966
Pointer to a block type.
Definition: Type.h:2687
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4444
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:3095
bool isFunctionType() const
Definition: Type.h:6387
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:723
CXXBasePath & front()
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2721
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Holds information about the various types of exception specification.
Definition: Type.h:3779
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
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1906
SourceManager & getSourceManager()
Definition: ASTContext.h:678
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2289
QualType getParamType(unsigned i) const
Definition: Type.h:3929
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:255
bool isVoidType() const
Definition: Type.h:6650
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:389
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:262
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2521
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D)
bool 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:2121
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:6391
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:655
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:377
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:17268
static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E)
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
Decl * getCalleeDecl()
Definition: Expr.h:2650
void setType(QualType newType)
Definition: Decl.h:656
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: Decl.h:97
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:2962