1 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file provides Sema routines for C++ exception specification testing.
11 //===----------------------------------------------------------------------===//
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"
27 static const FunctionProtoType *GetUnderlyingFunction(QualType T)
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>();
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);
45 // All the problem cases are member functions named "swap" within class
46 // templates declared directly within namespace std or std::__debug or
48 if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
49 !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
52 auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext());
56 bool IsInStd = ND->isStdNamespace();
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())
66 // Only apply this hack within a system header.
67 if (!Context.getSourceManager().isInSystemHeader(D.getBeginLoc()))
70 return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
72 .Case("pair", IsInStd)
73 .Case("priority_queue", IsInStd)
74 .Case("stack", IsInStd)
75 .Case("queue", IsInStd)
79 ExprResult Sema::ActOnNoexceptSpec(SourceLocation NoexceptLoc,
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;
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};
92 return ConstantExpr::Create(Context, BoolExpr, APValue{Value});
95 if (Converted.get()->isValueDependent()) {
96 EST = EST_DependentNoexcept;
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;
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.
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.
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);
129 QualType PointeeT = T;
130 if (const PointerType *PT = T->getAs<PointerType>()) {
131 PointeeT = PT->getPointeeType();
134 // cv void* is explicitly permitted, despite being a pointer to an
136 if (PointeeT->isVoidType())
138 } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
139 PointeeT = RT->getPointeeType();
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)
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;
165 if (!(PointeeT->isRecordType() &&
166 PointeeT->castAs<RecordType>()->isBeingDefined()) &&
167 RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
168 return ReturnValueOnError;
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
179 if (getLangOpts().CPlusPlus17)
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();
189 const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
193 return FnT->hasExceptionSpec();
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);
203 if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
206 FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
207 const FunctionProtoType *SourceFPT =
208 SourceDecl->getType()->castAs<FunctionProtoType>();
210 // If the exception specification has already been resolved, just return it.
211 if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType()))
214 // Compute or instantiate the exception specification now.
215 if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
216 EvaluateImplicitExceptionSpec(Loc, SourceDecl);
218 InstantiateExceptionSpec(Loc, SourceDecl);
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);
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);
237 for (FunctionDecl *Redecl : FD->redecls())
238 Context.adjustExceptionSpec(Redecl, ESI);
241 static bool exceptionSpecNotKnownYet(const FunctionDecl *FD) {
242 auto *MD = dyn_cast<CXXMethodDecl>(FD);
246 auto EST = MD->getType()->castAs<FunctionProtoType>()->getExceptionSpecType();
247 return EST == EST_Unparsed ||
248 (EST == EST_Unevaluated && MD->getParent()->isBeingDefined());
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);
259 /// Determine whether a function has an implicitly-generated exception
261 static bool hasImplicitExceptionSpec(FunctionDecl *Decl) {
262 if (!isa<CXXDestructorDecl>(Decl) &&
263 Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
264 Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
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);
275 auto *Ty = Decl->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
276 return !Ty->hasExceptionSpec();
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)
286 OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator();
287 bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
288 bool MissingExceptionSpecification = false;
289 bool MissingEmptyExceptionSpecification = false;
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;
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});
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);
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;
333 const FunctionProtoType *NewProto =
334 New->getType()->castAs<FunctionProtoType>();
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
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()) &&
349 New->setType(Context.getFunctionType(
350 NewProto->getReturnType(), NewProto->getParamTypes(),
351 NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone)));
355 const FunctionProtoType *OldProto =
356 Old->getType()->castAs<FunctionProtoType>();
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();
365 if (ESI.Type == EST_NoexceptFalse)
367 if (ESI.Type == EST_NoexceptTrue)
368 ESI.Type = EST_BasicNoexcept;
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();
375 // Update the type of the function with the appropriate exception
377 New->setType(Context.getFunctionType(
378 NewProto->getReturnType(), NewProto->getParamTypes(),
379 NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
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
395 DiagID = diag::ext_missing_exception_specification;
396 ReturnValueOnError = false;
398 DiagID = diag::err_missing_exception_specification;
399 ReturnValueOnError = true;
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:
412 bool OnFirstException = true;
413 for (const auto &E : OldProto->exceptions()) {
414 if (OnFirstException)
415 OnFirstException = false;
419 OS << E.getAsString(getPrintingPolicy());
425 case EST_BasicNoexcept:
429 case EST_DependentNoexcept:
430 case EST_NoexceptFalse:
431 case EST_NoexceptTrue:
433 assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
434 OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
438 OS <<"__attribute__((nothrow))";
442 case EST_Unevaluated:
443 case EST_Uninstantiated:
445 llvm_unreachable("This spec type is compatible with none.");
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());
458 if (FixItLoc.isInvalid())
459 Diag(New->getLocation(), DiagID)
462 Diag(New->getLocation(), DiagID)
464 << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
467 if (Old->getLocation().isValid())
468 Diag(Old->getLocation(), diag::note_previous_declaration);
470 return ReturnValueOnError;
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)
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);
490 // In Microsoft mode, mismatching exception specifications just cause a warning.
491 if (getLangOpts().MSVCCompat)
496 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
497 /// exception specifications. See C++ [except.spec]p3.
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;
512 if (MissingEmptyExceptionSpecification)
513 *MissingEmptyExceptionSpecification = false;
515 Old = S.ResolveExceptionSpec(NewLoc, Old);
518 New = S.ResolveExceptionSpec(NewLoc, New);
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
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.
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.
538 // That last point basically means that noexcept(false) matches no spec.
539 // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
541 ExceptionSpecificationType OldEST = Old->getExceptionSpecType();
542 ExceptionSpecificationType NewEST = New->getExceptionSpecType();
544 assert(!isUnresolvedExceptionSpec(OldEST) &&
545 !isUnresolvedExceptionSpec(NewEST) &&
546 "Shouldn't see unknown exception specifications here");
548 CanThrowResult OldCanThrow = Old->canThrow();
549 CanThrowResult NewCanThrow = New->canThrow();
551 // Any non-throwing specifications are compatible.
552 if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot)
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.
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)
580 // Dynamic exception specifications with the same set of adjusted types
582 if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) {
584 // Both have a dynamic exception spec. Collect the first set, then compare
586 llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
587 for (const auto &I : Old->exceptions())
588 OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
590 for (const auto &I : New->exceptions()) {
591 CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType();
592 if (OldTypes.count(TypePtr))
593 NewTypes.insert(TypePtr);
600 if (Success && OldTypes.size() == NewTypes.size())
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()) {
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;
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;
647 S.Diag(NewLoc, DiagID);
648 if (NoteID.getDiagID() != 0 && OldLoc.isValid())
649 S.Diag(OldLoc, NoteID);
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)
661 return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc,
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:
669 // HandlerType must be ExceptionType or derived from it, or pointer or
670 // reference to such types.
671 const ReferenceType *RefTy = HandlerType->getAs<ReferenceType>();
673 HandlerType = RefTy->getPointeeType();
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))
679 // FIXME: ObjC pointer types?
680 if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) {
681 if (RefTy && (!HandlerType.isConstQualified() ||
682 HandlerType.isVolatileQualified()))
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())
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
697 // FIXME: Should we treat the exception as catchable if a lifetime
698 // conversion is required?
699 if (IsQualificationConversion(ExceptionType, HandlerType, false,
701 IsFunctionConversion(ExceptionType, HandlerType, Result))
704 // -- a standard pointer conversion [...]
705 if (!ExceptionType->isPointerType() || !HandlerType->isPointerType())
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))
717 if (HandlerType->isVoidType() && ExceptionType->isObjectType())
720 // The only remaining case is a derived-to-base conversion.
723 // -- the handler is of type cg T or cv T& and T is an unambiguous public
725 if (!ExceptionType->isRecordType() || !HandlerType->isRecordType())
727 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
728 /*DetectVirtual=*/false);
729 if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) ||
730 Paths.isAmbiguous(Context.getCanonicalType(HandlerType)))
733 // Do this check from a context without privileges.
734 switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType,
738 /*ForceUnprivileged*/ true)) {
739 case AR_accessible: return true;
740 case AR_inaccessible: return false;
742 llvm_unreachable("access check dependent for unprivileged context");
744 llvm_unreachable("access check delayed in non-declaration");
746 llvm_unreachable("unexpected access check result");
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) {
761 // Just auto-succeed under -fno-exceptions.
762 if (!getLangOpts().CXXExceptions)
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.
768 if (!SubLoc.isValid())
771 // Resolve the exception specifications, if needed.
772 Superset = ResolveExceptionSpec(SuperLoc, Superset);
775 Subset = ResolveExceptionSpec(SubLoc, Subset);
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");
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)
792 CanThrowResult SuperCanThrow = Superset->canThrow();
793 CanThrowResult SubCanThrow = Subset->canThrow();
795 // If the superset contains everything or the subset contains nothing, we're
797 if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) ||
798 SubCanThrow == CT_Cannot)
799 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
802 // Allow __declspec(nothrow) to be missing on redeclaration as an extension in
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);
812 // If the subset contains everything or the superset contains nothing, we've
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);
822 assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
823 "Exception spec subset: non-dynamic case slipped through.");
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();
830 // Make sure it's in the superset.
831 bool Contained = false;
832 for (QualType SuperI : Superset->exceptions()) {
834 // the target entity shall allow at least the exceptions allowed by the
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)) {
845 Diag(SubLoc, DiagID);
846 if (NoteID.getDiagID() != 0)
847 Diag(SuperLoc, NoteID);
851 // We've run half the gauntlet.
852 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc,
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);
864 const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
868 return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
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;
885 if (CheckSpecForTypesEquivalent(
886 *this, RetDiag, PDiag(),
887 Target->getReturnType(), TargetLoc, Source->getReturnType(),
891 // We shouldn't even be testing this unless the arguments are otherwise
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;
898 if (CheckSpecForTypesEquivalent(
899 *this, ParamDiag, PDiag(),
900 Target->getParamType(i), TargetLoc, Source->getParamType(i),
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())
914 // SourceType must be a function or function pointer.
915 const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
916 if (!FromFunc || FromFunc->hasDependentExceptionSpec())
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;
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.
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;
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;
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() ==
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())
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});
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>(),
978 New->getType()->castAs<FunctionProtoType>(),
982 static CanThrowResult canSubStmtsThrow(Sema &Self, const Stmt *S) {
983 CanThrowResult R = CT_Cannot;
984 for (const Stmt *SubStmt : S->children()) {
987 R = mergeCanThrow(R, Self.canThrow(SubStmt));
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
1000 if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
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();
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();
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();
1020 T = cast<MemberExpr>(E)->getMemberDecl()->getType();
1023 } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
1026 // If we have no clue what we're calling, assume the worst.
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>();
1043 FT = S.ResolveExceptionSpec(Loc.isInvalid() ? E->getBeginLoc() : Loc, FT);
1047 return FT->canThrow();
1050 static CanThrowResult canVarDeclThrow(Sema &Self, const VarDecl *VD) {
1051 CanThrowResult CT = CT_Cannot;
1053 // Initialization might throw.
1054 if (!VD->isUsableInConstantExpressions(Self.Context))
1055 if (const Expr *Init = VD->getInit())
1056 CT = mergeCanThrow(CT, Self.canThrow(Init));
1058 // Destructor might throw.
1059 if (VD->needsDestruction(Self.Context) == QualType::DK_cxx_destructor) {
1061 VD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) {
1062 if (auto *Dtor = RD->getDestructor()) {
1064 CT, canCalleeThrow(Self, nullptr, Dtor, VD->getLocation()));
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));
1078 static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1079 if (DC->isTypeDependent())
1080 return CT_Dependent;
1082 if (!DC->getTypeAsWritten()->isReferenceType())
1085 if (DC->getSubExpr()->isTypeDependent())
1086 return CT_Dependent;
1088 return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
1091 static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) {
1092 if (DC->isTypeOperand())
1095 Expr *Op = DC->getExprOperand();
1096 if (Op->isTypeDependent())
1097 return CT_Dependent;
1099 const RecordType *RT = Op->getType()->getAs<RecordType>();
1103 if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1106 if (Op->Classify(S.Context).isPRValue())
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
1116 switch (S->getStmtClass()) {
1117 case Expr::ConstantExprClass:
1118 return canThrow(cast<ConstantExpr>(S)->getSubExpr());
1120 case Expr::CXXThrowExprClass:
1121 // - a potentially evaluated throw-expression
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())
1131 CanThrowResult CT = canDynamicCastThrow(CE);
1134 return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
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));
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);
1151 if (CE->isTypeDependent())
1153 else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1156 CT = canCalleeThrow(*this, CE, CE->getCalleeDecl());
1159 return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
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())
1168 CanThrowResult CT = canCalleeThrow(*this, CE, CE->getConstructor());
1171 return mergeCanThrow(CT, canSubStmtsThrow(*this, CE));
1174 case Expr::CXXInheritedCtorInitExprClass: {
1175 auto *ICIE = cast<CXXInheritedCtorInitExpr>(S);
1176 return canCalleeThrow(*this, ICIE, ICIE->getConstructor());
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));
1190 case Expr::CXXNewExprClass: {
1191 auto *NE = cast<CXXNewExpr>(S);
1193 if (NE->isTypeDependent())
1196 CT = canCalleeThrow(*this, NE, NE->getOperatorNew());
1199 return mergeCanThrow(CT, canSubStmtsThrow(*this, NE));
1202 case Expr::CXXDeleteExprClass: {
1203 auto *DE = cast<CXXDeleteExpr>(S);
1205 QualType DTy = DE->getDestroyedType();
1206 if (DTy.isNull() || DTy->isDependentType()) {
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();
1214 CT = mergeCanThrow(CT, canCalleeThrow(*this, DE, DD));
1219 return mergeCanThrow(CT, canSubStmtsThrow(*this, DE));
1222 case Expr::CXXBindTemporaryExprClass: {
1223 auto *BTE = cast<CXXBindTemporaryExpr>(S);
1224 // The bound temporary has to be destroyed again, which might throw.
1226 canCalleeThrow(*this, BTE, BTE->getTemporary()->getDestructor());
1229 return mergeCanThrow(CT, canSubStmtsThrow(*this, BTE));
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));
1243 // ObjC message sends are like function calls, but never have exception
1245 case Expr::ObjCMessageExprClass:
1246 case Expr::ObjCPropertyRefExprClass:
1247 case Expr::ObjCSubscriptRefExprClass:
1250 // All the ObjC literals that are implemented as calls are
1251 // potentially throwing unless we decide to close off that
1253 case Expr::ObjCArrayLiteralClass:
1254 case Expr::ObjCDictionaryLiteralClass:
1255 case Expr::ObjCBoxedExprClass:
1258 // Many other things have subexpressions, so we have to test those.
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);
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())
1289 return canSubStmtsThrow(*this, S);
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())
1308 cast<Expr>(S)->isTypeDependent() ? CT_Dependent : CT_Cannot;
1309 return mergeCanThrow(CT, canSubStmtsThrow(*this, S));
1312 case Expr::CXXDefaultArgExprClass:
1313 return canThrow(cast<CXXDefaultArgExpr>(S)->getExpr());
1315 case Expr::CXXDefaultInitExprClass:
1316 return canThrow(cast<CXXDefaultInitExpr>(S)->getExpr());
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());
1325 case Expr::GenericSelectionExprClass:
1326 if (cast<GenericSelectionExpr>(S)->isResultDependent())
1327 return CT_Dependent;
1328 return canThrow(cast<GenericSelectionExpr>(S)->getResultExpr());
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;
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.
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.
1393 case Expr::MSPropertyRefExprClass:
1394 case Expr::MSPropertySubscriptExprClass:
1395 llvm_unreachable("Invalid class for expression");
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);
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));
1490 // FIXME: Properly determine whether a variably-modified type can throw.
1491 if (auto *TND = dyn_cast<TypedefNameDecl>(D))
1492 if (TND->getUnderlyingType()->isVariablyModifiedType())
1494 if (auto *VD = dyn_cast<ValueDecl>(D))
1495 if (VD->getType()->isVariablyModifiedType())
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()));
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;
1515 CanThrowResult Then = canThrow(IS->getThen());
1516 CanThrowResult Else = IS->getElse() ? canThrow(IS->getElse()) : CT_Cannot;
1518 return mergeCanThrow(CT, Then);
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));
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);
1536 case Stmt::ObjCAtThrowStmtClass:
1539 case Stmt::ObjCAtTryStmtClass: {
1540 auto *TS = cast<ObjCAtTryStmt>(S);
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())
1555 // Didn't find an @catch(...). Exceptions from the @try body can escape.
1556 return mergeCanThrow(CT, canThrow(TS->getTryBody()));
1559 case Stmt::NoStmtClass:
1560 llvm_unreachable("Invalid class for statement");
1562 llvm_unreachable("Bogus StmtClass");
1565 } // end namespace clang