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