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