blob: e8d60d8b9c837f4956632a38d7471677c7544323 [file] [log] [blame]
Sebastian Redl4915e632009-10-11 09:03:14 +00001//===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides Sema routines for C++ exception specification testing.
11//
12//===----------------------------------------------------------------------===//
13
John McCall83024632010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Richard Smith564417a2014-03-20 21:47:22 +000015#include "clang/AST/ASTMutationListener.h"
Sebastian Redl4915e632009-10-11 09:03:14 +000016#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/ExprCXX.h"
Douglas Gregord6bc5e62010-03-24 07:14:45 +000019#include "clang/AST/TypeLoc.h"
Douglas Gregorf40863c2010-02-12 07:32:17 +000020#include "clang/Basic/Diagnostic.h"
21#include "clang/Basic/SourceManager.h"
Sebastian Redl4915e632009-10-11 09:03:14 +000022#include "llvm/ADT/SmallPtrSet.h"
Benjamin Kramer49038022012-02-04 13:45:25 +000023#include "llvm/ADT/SmallString.h"
Sebastian Redl4915e632009-10-11 09:03:14 +000024
25namespace clang {
26
27static const FunctionProtoType *GetUnderlyingFunction(QualType T)
28{
29 if (const PointerType *PtrTy = T->getAs<PointerType>())
30 T = PtrTy->getPointeeType();
31 else if (const ReferenceType *RefTy = T->getAs<ReferenceType>())
32 T = RefTy->getPointeeType();
Sebastian Redl075b21d2009-10-14 14:38:54 +000033 else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
34 T = MPTy->getPointeeType();
Sebastian Redl4915e632009-10-11 09:03:14 +000035 return T->getAs<FunctionProtoType>();
36}
37
Richard Smith6403e932014-11-14 00:37:55 +000038/// 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.
42bool Sema::isLibstdcxxEagerExceptionSpecHack(const Declarator &D) {
43 auto *RD = dyn_cast<CXXRecordDecl>(CurContext);
44
45 // All the problem cases are member functions named "swap" within class
46 // templates declared directly within namespace std.
47 if (!RD || RD->getEnclosingNamespaceContext() != getStdNamespace() ||
48 !RD->getIdentifier() || !RD->getDescribedClassTemplate() ||
49 !D.getIdentifier() || !D.getIdentifier()->isStr("swap"))
50 return false;
51
52 // Only apply this hack within a system header.
53 if (!Context.getSourceManager().isInSystemHeader(D.getLocStart()))
54 return false;
55
56 return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
57 .Case("array", true)
58 .Case("pair", true)
59 .Case("priority_queue", true)
60 .Case("stack", true)
61 .Case("queue", true)
62 .Default(false);
63}
64
Sebastian Redl4915e632009-10-11 09:03:14 +000065/// CheckSpecifiedExceptionType - Check if the given type is valid in an
66/// exception specification. Incomplete types, or pointers to incomplete types
67/// other than void are not allowed.
Richard Smith8606d752012-11-28 22:33:28 +000068///
69/// \param[in,out] T The exception type. This will be decayed to a pointer type
70/// when the input is an array or a function type.
71bool Sema::CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range) {
Richard Smitha118c6a2012-11-28 22:52:42 +000072 // C++11 [except.spec]p2:
73 // A type cv T, "array of T", or "function returning T" denoted
Richard Smith8606d752012-11-28 22:33:28 +000074 // in an exception-specification is adjusted to type T, "pointer to T", or
75 // "pointer to function returning T", respectively.
Richard Smitha118c6a2012-11-28 22:52:42 +000076 //
77 // We also apply this rule in C++98.
Richard Smith8606d752012-11-28 22:33:28 +000078 if (T->isArrayType())
79 T = Context.getArrayDecayedType(T);
80 else if (T->isFunctionType())
81 T = Context.getPointerType(T);
Sebastian Redl4915e632009-10-11 09:03:14 +000082
Richard Smitha118c6a2012-11-28 22:52:42 +000083 int Kind = 0;
Richard Smith8606d752012-11-28 22:33:28 +000084 QualType PointeeT = T;
Richard Smitha118c6a2012-11-28 22:52:42 +000085 if (const PointerType *PT = T->getAs<PointerType>()) {
86 PointeeT = PT->getPointeeType();
87 Kind = 1;
Sebastian Redl4915e632009-10-11 09:03:14 +000088
Richard Smitha118c6a2012-11-28 22:52:42 +000089 // cv void* is explicitly permitted, despite being a pointer to an
90 // incomplete type.
91 if (PointeeT->isVoidType())
92 return false;
93 } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
94 PointeeT = RT->getPointeeType();
95 Kind = 2;
Richard Smith8606d752012-11-28 22:33:28 +000096
Richard Smitha118c6a2012-11-28 22:52:42 +000097 if (RT->isRValueReferenceType()) {
98 // C++11 [except.spec]p2:
99 // A type denoted in an exception-specification shall not denote [...]
100 // an rvalue reference type.
101 Diag(Range.getBegin(), diag::err_rref_in_exception_spec)
102 << T << Range;
103 return true;
104 }
105 }
106
107 // C++11 [except.spec]p2:
108 // A type denoted in an exception-specification shall not denote an
109 // incomplete type other than a class currently being defined [...].
110 // A type denoted in an exception-specification shall not denote a
111 // pointer or reference to an incomplete type, other than (cv) void* or a
112 // pointer or reference to a class currently being defined.
113 if (!(PointeeT->isRecordType() &&
114 PointeeT->getAs<RecordType>()->isBeingDefined()) &&
Richard Smith8606d752012-11-28 22:33:28 +0000115 RequireCompleteType(Range.getBegin(), PointeeT,
Richard Smitha118c6a2012-11-28 22:52:42 +0000116 diag::err_incomplete_in_exception_spec, Kind, Range))
Sebastian Redl7eb5d372009-10-14 14:59:48 +0000117 return true;
Sebastian Redl4915e632009-10-11 09:03:14 +0000118
119 return false;
120}
121
122/// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
123/// to member to a function with an exception specification. This means that
124/// it is invalid to add another level of indirection.
125bool Sema::CheckDistantExceptionSpec(QualType T) {
126 if (const PointerType *PT = T->getAs<PointerType>())
127 T = PT->getPointeeType();
128 else if (const MemberPointerType *PT = T->getAs<MemberPointerType>())
129 T = PT->getPointeeType();
130 else
131 return false;
132
133 const FunctionProtoType *FnT = T->getAs<FunctionProtoType>();
134 if (!FnT)
135 return false;
136
137 return FnT->hasExceptionSpec();
138}
139
Richard Smithf623c962012-04-17 00:58:00 +0000140const FunctionProtoType *
141Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) {
Richard Smith0b3a4622014-11-13 20:01:57 +0000142 if (FPT->getExceptionSpecType() == EST_Unparsed) {
143 Diag(Loc, diag::err_exception_spec_not_parsed);
144 return nullptr;
145 }
146
Richard Smithd3b5c9082012-07-27 04:22:15 +0000147 if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
Richard Smithf623c962012-04-17 00:58:00 +0000148 return FPT;
149
150 FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl();
151 const FunctionProtoType *SourceFPT =
152 SourceDecl->getType()->castAs<FunctionProtoType>();
153
Richard Smithd3b5c9082012-07-27 04:22:15 +0000154 // If the exception specification has already been resolved, just return it.
155 if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType()))
Richard Smithf623c962012-04-17 00:58:00 +0000156 return SourceFPT;
157
Richard Smithd3b5c9082012-07-27 04:22:15 +0000158 // Compute or instantiate the exception specification now.
Richard Smith3901dfe2013-03-27 00:22:47 +0000159 if (SourceFPT->getExceptionSpecType() == EST_Unevaluated)
Richard Smithd3b5c9082012-07-27 04:22:15 +0000160 EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl));
161 else
162 InstantiateExceptionSpec(Loc, SourceDecl);
Richard Smithf623c962012-04-17 00:58:00 +0000163
Davide Italiano922b7022015-07-25 01:19:32 +0000164 const FunctionProtoType *Proto =
165 SourceDecl->getType()->castAs<FunctionProtoType>();
166 if (Proto->getExceptionSpecType() == clang::EST_Unparsed) {
167 Diag(Loc, diag::err_exception_spec_not_parsed);
168 Proto = nullptr;
169 }
170 return Proto;
Richard Smithf623c962012-04-17 00:58:00 +0000171}
172
Richard Smith8acb4282014-07-31 21:57:55 +0000173void
174Sema::UpdateExceptionSpec(FunctionDecl *FD,
175 const FunctionProtoType::ExceptionSpecInfo &ESI) {
Richard Smith564417a2014-03-20 21:47:22 +0000176 // If we've fully resolved the exception specification, notify listeners.
Richard Smith8acb4282014-07-31 21:57:55 +0000177 if (!isUnresolvedExceptionSpec(ESI.Type))
Richard Smith564417a2014-03-20 21:47:22 +0000178 if (auto *Listener = getASTMutationListener())
179 Listener->ResolvedExceptionSpec(FD);
Richard Smith9e2341d2015-03-23 03:25:59 +0000180
181 for (auto *Redecl : FD->redecls())
182 Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
Richard Smith564417a2014-03-20 21:47:22 +0000183}
184
Richard Smith66f3ac92012-10-20 08:26:51 +0000185/// Determine whether a function has an implicitly-generated exception
Richard Smith1ee63522012-10-16 23:30:16 +0000186/// specification.
Richard Smith66f3ac92012-10-20 08:26:51 +0000187static bool hasImplicitExceptionSpec(FunctionDecl *Decl) {
188 if (!isa<CXXDestructorDecl>(Decl) &&
189 Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete &&
190 Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
191 return false;
Richard Smith1ee63522012-10-16 23:30:16 +0000192
Richard Smithc7fb2252014-02-07 22:51:16 +0000193 // For a function that the user didn't declare:
194 // - if this is a destructor, its exception specification is implicit.
195 // - if this is 'operator delete' or 'operator delete[]', the exception
196 // specification is as-if an explicit exception specification was given
197 // (per [basic.stc.dynamic]p2).
Richard Smith66f3ac92012-10-20 08:26:51 +0000198 if (!Decl->getTypeSourceInfo())
Richard Smithc7fb2252014-02-07 22:51:16 +0000199 return isa<CXXDestructorDecl>(Decl);
Richard Smith66f3ac92012-10-20 08:26:51 +0000200
201 const FunctionProtoType *Ty =
202 Decl->getTypeSourceInfo()->getType()->getAs<FunctionProtoType>();
203 return !Ty->hasExceptionSpec();
Richard Smith1ee63522012-10-16 23:30:16 +0000204}
205
Douglas Gregorf40863c2010-02-12 07:32:17 +0000206bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
Sebastian Redlcb5dd002011-03-15 19:52:30 +0000207 OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator();
208 bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000209 bool MissingExceptionSpecification = false;
Douglas Gregorf40863c2010-02-12 07:32:17 +0000210 bool MissingEmptyExceptionSpecification = false;
Hans Wennborg39a509a2014-02-05 02:37:58 +0000211
Francois Pichet13b4e682011-03-19 23:05:18 +0000212 unsigned DiagID = diag::err_mismatched_exception_spec;
Hans Wennborg39a509a2014-02-05 02:37:58 +0000213 bool ReturnValueOnError = true;
214 if (getLangOpts().MicrosoftExt) {
Richard Smith1b98ccc2014-07-19 01:39:17 +0000215 DiagID = diag::ext_mismatched_exception_spec;
Hans Wennborg39a509a2014-02-05 02:37:58 +0000216 ReturnValueOnError = false;
217 }
Richard Smithf623c962012-04-17 00:58:00 +0000218
Richard Smith1ee63522012-10-16 23:30:16 +0000219 // Check the types as written: they must match before any exception
220 // specification adjustment is applied.
221 if (!CheckEquivalentExceptionSpec(
222 PDiag(DiagID), PDiag(diag::note_previous_declaration),
Richard Smith66f3ac92012-10-20 08:26:51 +0000223 Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(),
224 New->getType()->getAs<FunctionProtoType>(), New->getLocation(),
Richard Smith1ee63522012-10-16 23:30:16 +0000225 &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,
Richard Smith66f3ac92012-10-20 08:26:51 +0000226 /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) {
227 // C++11 [except.spec]p4 [DR1492]:
228 // If a declaration of a function has an implicit
229 // exception-specification, other declarations of the function shall
230 // not specify an exception-specification.
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000231 if (getLangOpts().CPlusPlus11 &&
Richard Smith66f3ac92012-10-20 08:26:51 +0000232 hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) {
233 Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch)
234 << hasImplicitExceptionSpec(Old);
Yaron Keren8b563662015-10-03 10:46:20 +0000235 if (Old->getLocation().isValid())
Richard Smith66f3ac92012-10-20 08:26:51 +0000236 Diag(Old->getLocation(), diag::note_previous_declaration);
237 }
Douglas Gregorf40863c2010-02-12 07:32:17 +0000238 return false;
Richard Smith66f3ac92012-10-20 08:26:51 +0000239 }
Douglas Gregorf40863c2010-02-12 07:32:17 +0000240
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000241 // The failure was something other than an missing exception
Hans Wennborg39a509a2014-02-05 02:37:58 +0000242 // specification; return an error, except in MS mode where this is a warning.
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000243 if (!MissingExceptionSpecification)
Hans Wennborg39a509a2014-02-05 02:37:58 +0000244 return ReturnValueOnError;
Douglas Gregorf40863c2010-02-12 07:32:17 +0000245
Richard Smith66f3ac92012-10-20 08:26:51 +0000246 const FunctionProtoType *NewProto =
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000247 New->getType()->castAs<FunctionProtoType>();
John McCalldb40c7f2010-12-14 08:05:40 +0000248
Douglas Gregorf40863c2010-02-12 07:32:17 +0000249 // The new function declaration is only missing an empty exception
250 // specification "throw()". If the throw() specification came from a
251 // function in a system header that has C linkage, just add an empty
252 // exception specification to the "new" declaration. This is an
253 // egregious workaround for glibc, which adds throw() specifications
254 // to many libc functions as an optimization. Unfortunately, that
255 // optimization isn't permitted by the C++ standard, so we're forced
256 // to work around it here.
John McCalldb40c7f2010-12-14 08:05:40 +0000257 if (MissingEmptyExceptionSpecification && NewProto &&
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000258 (Old->getLocation().isInvalid() ||
259 Context.getSourceManager().isInSystemHeader(Old->getLocation())) &&
Douglas Gregorf40863c2010-02-12 07:32:17 +0000260 Old->isExternC()) {
Richard Smith8acb4282014-07-31 21:57:55 +0000261 New->setType(Context.getFunctionType(
262 NewProto->getReturnType(), NewProto->getParamTypes(),
263 NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone)));
Douglas Gregorf40863c2010-02-12 07:32:17 +0000264 return false;
265 }
266
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000267 const FunctionProtoType *OldProto =
268 Old->getType()->castAs<FunctionProtoType>();
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000269
Richard Smith8acb4282014-07-31 21:57:55 +0000270 FunctionProtoType::ExceptionSpecInfo ESI = OldProto->getExceptionSpecType();
271 if (ESI.Type == EST_Dynamic) {
272 ESI.Exceptions = OldProto->exceptions();
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000273 }
274
Richard Smitha91de372015-09-30 00:48:50 +0000275 if (ESI.Type == EST_ComputedNoexcept) {
276 // For computed noexcept, we can't just take the expression from the old
277 // prototype. It likely contains references to the old prototype's
278 // parameters.
279 New->setInvalidDecl();
280 } else {
281 // Update the type of the function with the appropriate exception
282 // specification.
283 New->setType(Context.getFunctionType(
284 NewProto->getReturnType(), NewProto->getParamTypes(),
285 NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
286 }
287
288 // Allow missing exception specifications in redeclarations as an extension,
289 // when declaring a replaceable global allocation function.
290 if (New->isReplaceableGlobalAllocationFunction() &&
291 ESI.Type != EST_ComputedNoexcept) {
292 DiagID = diag::ext_missing_exception_specification;
293 ReturnValueOnError = false;
294 } else {
295 DiagID = diag::err_missing_exception_specification;
296 ReturnValueOnError = true;
297 }
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000298
299 // Warn about the lack of exception specification.
300 SmallString<128> ExceptionSpecString;
301 llvm::raw_svector_ostream OS(ExceptionSpecString);
302 switch (OldProto->getExceptionSpecType()) {
303 case EST_DynamicNone:
304 OS << "throw()";
305 break;
306
307 case EST_Dynamic: {
308 OS << "throw(";
309 bool OnFirstException = true;
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000310 for (const auto &E : OldProto->exceptions()) {
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000311 if (OnFirstException)
312 OnFirstException = false;
313 else
314 OS << ", ";
315
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000316 OS << E.getAsString(getPrintingPolicy());
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000317 }
318 OS << ")";
319 break;
320 }
321
322 case EST_BasicNoexcept:
323 OS << "noexcept";
324 break;
325
326 case EST_ComputedNoexcept:
327 OS << "noexcept(";
Richard Trieuddd01ce2014-06-09 22:53:25 +0000328 assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
Craig Topperc3ec1492014-05-26 06:22:03 +0000329 OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000330 OS << ")";
331 break;
332
333 default:
334 llvm_unreachable("This spec type is compatible with none.");
335 }
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000336
337 SourceLocation FixItLoc;
338 if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
339 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
Richard Smitha91de372015-09-30 00:48:50 +0000340 // FIXME: Preserve enough information so that we can produce a correct fixit
341 // location when there is a trailing return type.
342 if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>())
343 if (!FTLoc.getTypePtr()->hasTrailingReturn())
344 FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd());
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000345 }
346
347 if (FixItLoc.isInvalid())
Richard Smitha91de372015-09-30 00:48:50 +0000348 Diag(New->getLocation(), DiagID)
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000349 << New << OS.str();
350 else {
Richard Smitha91de372015-09-30 00:48:50 +0000351 Diag(New->getLocation(), DiagID)
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000352 << New << OS.str()
353 << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str());
354 }
355
Yaron Keren8b563662015-10-03 10:46:20 +0000356 if (Old->getLocation().isValid())
Eli Friedman96dbf6f2013-06-25 00:46:32 +0000357 Diag(Old->getLocation(), diag::note_previous_declaration);
358
Richard Smitha91de372015-09-30 00:48:50 +0000359 return ReturnValueOnError;
Douglas Gregorf40863c2010-02-12 07:32:17 +0000360}
361
Sebastian Redl4915e632009-10-11 09:03:14 +0000362/// CheckEquivalentExceptionSpec - Check if the two types have equivalent
363/// exception specifications. Exception specifications are equivalent if
364/// they allow exactly the same set of exception types. It does not matter how
365/// that is achieved. See C++ [except.spec]p2.
366bool Sema::CheckEquivalentExceptionSpec(
367 const FunctionProtoType *Old, SourceLocation OldLoc,
368 const FunctionProtoType *New, SourceLocation NewLoc) {
Francois Pichet13b4e682011-03-19 23:05:18 +0000369 unsigned DiagID = diag::err_mismatched_exception_spec;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000370 if (getLangOpts().MicrosoftExt)
Richard Smith1b98ccc2014-07-19 01:39:17 +0000371 DiagID = diag::ext_mismatched_exception_spec;
Hans Wennborg39a509a2014-02-05 02:37:58 +0000372 bool Result = CheckEquivalentExceptionSpec(PDiag(DiagID),
373 PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc);
374
375 // In Microsoft mode, mismatching exception specifications just cause a warning.
376 if (getLangOpts().MicrosoftExt)
377 return false;
378 return Result;
Sebastian Redl4915e632009-10-11 09:03:14 +0000379}
380
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000381/// CheckEquivalentExceptionSpec - Check if the two types have compatible
382/// exception specifications. See C++ [except.spec]p3.
Richard Smith66f3ac92012-10-20 08:26:51 +0000383///
384/// \return \c false if the exception specifications match, \c true if there is
385/// a problem. If \c true is returned, either a diagnostic has already been
386/// produced or \c *MissingExceptionSpecification is set to \c true.
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000387bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID,
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000388 const PartialDiagnostic & NoteID,
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000389 const FunctionProtoType *Old,
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000390 SourceLocation OldLoc,
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000391 const FunctionProtoType *New,
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000392 SourceLocation NewLoc,
393 bool *MissingExceptionSpecification,
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000394 bool*MissingEmptyExceptionSpecification,
Sebastian Redlcb5dd002011-03-15 19:52:30 +0000395 bool AllowNoexceptAllMatchWithNoSpec,
396 bool IsOperatorNew) {
John McCallf9c94092010-05-28 08:37:35 +0000397 // Just completely ignore this under -fno-exceptions.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000398 if (!getLangOpts().CXXExceptions)
John McCallf9c94092010-05-28 08:37:35 +0000399 return false;
400
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000401 if (MissingExceptionSpecification)
402 *MissingExceptionSpecification = false;
403
Douglas Gregorf40863c2010-02-12 07:32:17 +0000404 if (MissingEmptyExceptionSpecification)
405 *MissingEmptyExceptionSpecification = false;
406
Richard Smithf623c962012-04-17 00:58:00 +0000407 Old = ResolveExceptionSpec(NewLoc, Old);
408 if (!Old)
409 return false;
410 New = ResolveExceptionSpec(NewLoc, New);
411 if (!New)
412 return false;
413
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000414 // C++0x [except.spec]p3: Two exception-specifications are compatible if:
415 // - both are non-throwing, regardless of their form,
416 // - both have the form noexcept(constant-expression) and the constant-
417 // expressions are equivalent,
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000418 // - both are dynamic-exception-specifications that have the same set of
419 // adjusted types.
420 //
Eric Christophere6b7cf42015-07-10 18:25:52 +0000421 // C++0x [except.spec]p12: An exception-specification is non-throwing if it is
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000422 // of the form throw(), noexcept, or noexcept(constant-expression) where the
423 // constant-expression yields true.
424 //
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000425 // C++0x [except.spec]p4: If any declaration of a function has an exception-
426 // specifier that is not a noexcept-specification allowing all exceptions,
427 // all declarations [...] of that function shall have a compatible
428 // exception-specification.
429 //
430 // That last point basically means that noexcept(false) matches no spec.
431 // It's considered when AllowNoexceptAllMatchWithNoSpec is true.
432
433 ExceptionSpecificationType OldEST = Old->getExceptionSpecType();
434 ExceptionSpecificationType NewEST = New->getExceptionSpecType();
435
Richard Smithd3b5c9082012-07-27 04:22:15 +0000436 assert(!isUnresolvedExceptionSpec(OldEST) &&
437 !isUnresolvedExceptionSpec(NewEST) &&
Richard Smith938f40b2011-06-11 17:19:42 +0000438 "Shouldn't see unknown exception specifications here");
439
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000440 // Shortcut the case where both have no spec.
441 if (OldEST == EST_None && NewEST == EST_None)
442 return false;
443
Sebastian Redl31ad7542011-03-13 17:09:40 +0000444 FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context);
445 FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context);
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000446 if (OldNR == FunctionProtoType::NR_BadNoexcept ||
447 NewNR == FunctionProtoType::NR_BadNoexcept)
448 return false;
449
450 // Dependent noexcept specifiers are compatible with each other, but nothing
451 // else.
452 // One noexcept is compatible with another if the argument is the same
453 if (OldNR == NewNR &&
454 OldNR != FunctionProtoType::NR_NoNoexcept &&
455 NewNR != FunctionProtoType::NR_NoNoexcept)
456 return false;
457 if (OldNR != NewNR &&
458 OldNR != FunctionProtoType::NR_NoNoexcept &&
459 NewNR != FunctionProtoType::NR_NoNoexcept) {
460 Diag(NewLoc, DiagID);
David Majnemer7da23022015-02-19 07:28:55 +0000461 if (NoteID.getDiagID() != 0 && OldLoc.isValid())
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000462 Diag(OldLoc, NoteID);
463 return true;
Douglas Gregorf62c5292010-08-30 15:04:51 +0000464 }
465
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000466 // The MS extension throw(...) is compatible with itself.
467 if (OldEST == EST_MSAny && NewEST == EST_MSAny)
Sebastian Redl4915e632009-10-11 09:03:14 +0000468 return false;
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000469
470 // It's also compatible with no spec.
471 if ((OldEST == EST_None && NewEST == EST_MSAny) ||
472 (OldEST == EST_MSAny && NewEST == EST_None))
473 return false;
474
475 // It's also compatible with noexcept(false).
476 if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw)
477 return false;
478 if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw)
479 return false;
480
481 // As described above, noexcept(false) matches no spec only for functions.
482 if (AllowNoexceptAllMatchWithNoSpec) {
483 if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw)
484 return false;
485 if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw)
486 return false;
487 }
488
489 // Any non-throwing specifications are compatible.
490 bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow ||
491 OldEST == EST_DynamicNone;
492 bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow ||
493 NewEST == EST_DynamicNone;
494 if (OldNonThrowing && NewNonThrowing)
495 return false;
496
Sebastian Redlcb5dd002011-03-15 19:52:30 +0000497 // As a special compatibility feature, under C++0x we accept no spec and
498 // throw(std::bad_alloc) as equivalent for operator new and operator new[].
499 // This is because the implicit declaration changed, but old code would break.
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000500 if (getLangOpts().CPlusPlus11 && IsOperatorNew) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000501 const FunctionProtoType *WithExceptions = nullptr;
Sebastian Redlcb5dd002011-03-15 19:52:30 +0000502 if (OldEST == EST_None && NewEST == EST_Dynamic)
503 WithExceptions = New;
504 else if (OldEST == EST_Dynamic && NewEST == EST_None)
505 WithExceptions = Old;
506 if (WithExceptions && WithExceptions->getNumExceptions() == 1) {
507 // One has no spec, the other throw(something). If that something is
508 // std::bad_alloc, all conditions are met.
509 QualType Exception = *WithExceptions->exception_begin();
510 if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) {
511 IdentifierInfo* Name = ExRecord->getIdentifier();
512 if (Name && Name->getName() == "bad_alloc") {
513 // It's called bad_alloc, but is it in std?
Richard Trieuc771d5d2014-05-28 02:16:01 +0000514 if (ExRecord->isInStdNamespace()) {
515 return false;
Sebastian Redlcb5dd002011-03-15 19:52:30 +0000516 }
517 }
518 }
519 }
520 }
521
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000522 // At this point, the only remaining valid case is two matching dynamic
523 // specifications. We return here unless both specifications are dynamic.
524 if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) {
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000525 if (MissingExceptionSpecification && Old->hasExceptionSpec() &&
Douglas Gregorf40863c2010-02-12 07:32:17 +0000526 !New->hasExceptionSpec()) {
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000527 // The old type has an exception specification of some sort, but
528 // the new type does not.
529 *MissingExceptionSpecification = true;
530
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000531 if (MissingEmptyExceptionSpecification && OldNonThrowing) {
532 // The old type has a throw() or noexcept(true) exception specification
533 // and the new type has no exception specification, and the caller asked
Douglas Gregord6bc5e62010-03-24 07:14:45 +0000534 // to handle this itself.
535 *MissingEmptyExceptionSpecification = true;
536 }
537
Douglas Gregorf40863c2010-02-12 07:32:17 +0000538 return true;
539 }
540
Sebastian Redl4915e632009-10-11 09:03:14 +0000541 Diag(NewLoc, DiagID);
David Majnemer7da23022015-02-19 07:28:55 +0000542 if (NoteID.getDiagID() != 0 && OldLoc.isValid())
Sebastian Redl4915e632009-10-11 09:03:14 +0000543 Diag(OldLoc, NoteID);
544 return true;
545 }
546
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000547 assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic &&
548 "Exception compatibility logic error: non-dynamic spec slipped through.");
549
Sebastian Redl4915e632009-10-11 09:03:14 +0000550 bool Success = true;
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000551 // Both have a dynamic exception spec. Collect the first set, then compare
Sebastian Redl4915e632009-10-11 09:03:14 +0000552 // to the second.
Sebastian Redl184edca2009-10-14 15:06:25 +0000553 llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes;
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000554 for (const auto &I : Old->exceptions())
555 OldTypes.insert(Context.getCanonicalType(I).getUnqualifiedType());
Sebastian Redl4915e632009-10-11 09:03:14 +0000556
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000557 for (const auto &I : New->exceptions()) {
558 CanQualType TypePtr = Context.getCanonicalType(I).getUnqualifiedType();
Sebastian Redl6e4c8712009-10-11 09:11:23 +0000559 if(OldTypes.count(TypePtr))
560 NewTypes.insert(TypePtr);
561 else
562 Success = false;
563 }
Sebastian Redl4915e632009-10-11 09:03:14 +0000564
Sebastian Redl6e4c8712009-10-11 09:11:23 +0000565 Success = Success && OldTypes.size() == NewTypes.size();
Sebastian Redl4915e632009-10-11 09:03:14 +0000566
567 if (Success) {
568 return false;
569 }
570 Diag(NewLoc, DiagID);
David Majnemer7da23022015-02-19 07:28:55 +0000571 if (NoteID.getDiagID() != 0 && OldLoc.isValid())
Sebastian Redl4915e632009-10-11 09:03:14 +0000572 Diag(OldLoc, NoteID);
573 return true;
574}
575
576/// CheckExceptionSpecSubset - Check whether the second function type's
577/// exception specification is a subset (or equivalent) of the first function
578/// type. This is used by override and pointer assignment checks.
Sebastian Redla44822f2009-10-14 16:09:29 +0000579bool Sema::CheckExceptionSpecSubset(
580 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redl4915e632009-10-11 09:03:14 +0000581 const FunctionProtoType *Superset, SourceLocation SuperLoc,
582 const FunctionProtoType *Subset, SourceLocation SubLoc) {
John McCallf9c94092010-05-28 08:37:35 +0000583
584 // Just auto-succeed under -fno-exceptions.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000585 if (!getLangOpts().CXXExceptions)
John McCallf9c94092010-05-28 08:37:35 +0000586 return false;
587
Sebastian Redl4915e632009-10-11 09:03:14 +0000588 // FIXME: As usual, we could be more specific in our error messages, but
589 // that better waits until we've got types with source locations.
590
591 if (!SubLoc.isValid())
592 SubLoc = SuperLoc;
593
Richard Smithf623c962012-04-17 00:58:00 +0000594 // Resolve the exception specifications, if needed.
595 Superset = ResolveExceptionSpec(SuperLoc, Superset);
596 if (!Superset)
597 return false;
598 Subset = ResolveExceptionSpec(SubLoc, Subset);
599 if (!Subset)
600 return false;
601
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000602 ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType();
603
Sebastian Redl4915e632009-10-11 09:03:14 +0000604 // If superset contains everything, we're done.
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000605 if (SuperEST == EST_None || SuperEST == EST_MSAny)
Sebastian Redl4915e632009-10-11 09:03:14 +0000606 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
607
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000608 // If there are dependent noexcept specs, assume everything is fine. Unlike
609 // with the equivalency check, this is safe in this case, because we don't
610 // want to merge declarations. Checks after instantiation will catch any
611 // omissions we make here.
612 // We also shortcut checking if a noexcept expression was bad.
613
Sebastian Redl31ad7542011-03-13 17:09:40 +0000614 FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context);
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000615 if (SuperNR == FunctionProtoType::NR_BadNoexcept ||
616 SuperNR == FunctionProtoType::NR_Dependent)
617 return false;
618
619 // Another case of the superset containing everything.
620 if (SuperNR == FunctionProtoType::NR_Throw)
621 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
622
623 ExceptionSpecificationType SubEST = Subset->getExceptionSpecType();
624
Richard Smithd3b5c9082012-07-27 04:22:15 +0000625 assert(!isUnresolvedExceptionSpec(SuperEST) &&
626 !isUnresolvedExceptionSpec(SubEST) &&
Richard Smith938f40b2011-06-11 17:19:42 +0000627 "Shouldn't see unknown exception specifications here");
628
Sebastian Redl4915e632009-10-11 09:03:14 +0000629 // It does not. If the subset contains everything, we've failed.
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000630 if (SubEST == EST_None || SubEST == EST_MSAny) {
Sebastian Redl4915e632009-10-11 09:03:14 +0000631 Diag(SubLoc, DiagID);
Sebastian Redla44822f2009-10-14 16:09:29 +0000632 if (NoteID.getDiagID() != 0)
Sebastian Redl4915e632009-10-11 09:03:14 +0000633 Diag(SuperLoc, NoteID);
634 return true;
635 }
636
Sebastian Redl31ad7542011-03-13 17:09:40 +0000637 FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context);
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000638 if (SubNR == FunctionProtoType::NR_BadNoexcept ||
639 SubNR == FunctionProtoType::NR_Dependent)
640 return false;
641
642 // Another case of the subset containing everything.
643 if (SubNR == FunctionProtoType::NR_Throw) {
644 Diag(SubLoc, DiagID);
645 if (NoteID.getDiagID() != 0)
646 Diag(SuperLoc, NoteID);
647 return true;
648 }
649
650 // If the subset contains nothing, we're done.
651 if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow)
652 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
653
654 // Otherwise, if the superset contains nothing, we've failed.
655 if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) {
656 Diag(SubLoc, DiagID);
657 if (NoteID.getDiagID() != 0)
658 Diag(SuperLoc, NoteID);
659 return true;
660 }
661
662 assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic &&
663 "Exception spec subset: non-dynamic case slipped through.");
664
665 // Neither contains everything or nothing. Do a proper comparison.
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000666 for (const auto &SubI : Subset->exceptions()) {
Sebastian Redl4915e632009-10-11 09:03:14 +0000667 // Take one type from the subset.
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000668 QualType CanonicalSubT = Context.getCanonicalType(SubI);
Sebastian Redl075b21d2009-10-14 14:38:54 +0000669 // Unwrap pointers and references so that we can do checks within a class
670 // hierarchy. Don't unwrap member pointers; they don't have hierarchy
671 // conversions on the pointee.
Sebastian Redl4915e632009-10-11 09:03:14 +0000672 bool SubIsPointer = false;
673 if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>())
674 CanonicalSubT = RefTy->getPointeeType();
675 if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) {
676 CanonicalSubT = PtrTy->getPointeeType();
677 SubIsPointer = true;
678 }
679 bool SubIsClass = CanonicalSubT->isRecordType();
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000680 CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType();
Sebastian Redl4915e632009-10-11 09:03:14 +0000681
682 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
683 /*DetectVirtual=*/false);
684
685 bool Contained = false;
686 // Make sure it's in the superset.
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000687 for (const auto &SuperI : Superset->exceptions()) {
688 QualType CanonicalSuperT = Context.getCanonicalType(SuperI);
Sebastian Redl4915e632009-10-11 09:03:14 +0000689 // SubT must be SuperT or derived from it, or pointer or reference to
690 // such types.
691 if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>())
692 CanonicalSuperT = RefTy->getPointeeType();
693 if (SubIsPointer) {
694 if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>())
695 CanonicalSuperT = PtrTy->getPointeeType();
696 else {
697 continue;
698 }
699 }
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +0000700 CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType();
Sebastian Redl4915e632009-10-11 09:03:14 +0000701 // If the types are the same, move on to the next type in the subset.
702 if (CanonicalSubT == CanonicalSuperT) {
703 Contained = true;
704 break;
705 }
706
707 // Otherwise we need to check the inheritance.
708 if (!SubIsClass || !CanonicalSuperT->isRecordType())
709 continue;
710
711 Paths.clear();
712 if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths))
713 continue;
714
Douglas Gregor27ac4292010-05-21 20:29:55 +0000715 if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT)))
Sebastian Redl4915e632009-10-11 09:03:14 +0000716 continue;
717
John McCall5b0829a2010-02-10 09:31:12 +0000718 // Do this check from a context without privileges.
John McCall1064d7e2010-03-16 05:22:47 +0000719 switch (CheckBaseClassAccess(SourceLocation(),
John McCall5b0829a2010-02-10 09:31:12 +0000720 CanonicalSuperT, CanonicalSubT,
721 Paths.front(),
John McCall1064d7e2010-03-16 05:22:47 +0000722 /*Diagnostic*/ 0,
John McCall5b0829a2010-02-10 09:31:12 +0000723 /*ForceCheck*/ true,
John McCall1064d7e2010-03-16 05:22:47 +0000724 /*ForceUnprivileged*/ true)) {
John McCall5b0829a2010-02-10 09:31:12 +0000725 case AR_accessible: break;
726 case AR_inaccessible: continue;
727 case AR_dependent:
728 llvm_unreachable("access check dependent for unprivileged context");
John McCall5b0829a2010-02-10 09:31:12 +0000729 case AR_delayed:
730 llvm_unreachable("access check delayed in non-declaration");
John McCall5b0829a2010-02-10 09:31:12 +0000731 }
Sebastian Redl4915e632009-10-11 09:03:14 +0000732
733 Contained = true;
734 break;
735 }
736 if (!Contained) {
737 Diag(SubLoc, DiagID);
Sebastian Redla44822f2009-10-14 16:09:29 +0000738 if (NoteID.getDiagID() != 0)
Sebastian Redl4915e632009-10-11 09:03:14 +0000739 Diag(SuperLoc, NoteID);
740 return true;
741 }
742 }
743 // We've run half the gauntlet.
744 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc);
745}
746
747static bool CheckSpecForTypesEquivalent(Sema &S,
Sebastian Redla44822f2009-10-14 16:09:29 +0000748 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redl4915e632009-10-11 09:03:14 +0000749 QualType Target, SourceLocation TargetLoc,
750 QualType Source, SourceLocation SourceLoc)
751{
752 const FunctionProtoType *TFunc = GetUnderlyingFunction(Target);
753 if (!TFunc)
754 return false;
755 const FunctionProtoType *SFunc = GetUnderlyingFunction(Source);
756 if (!SFunc)
757 return false;
758
759 return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc,
760 SFunc, SourceLoc);
761}
762
763/// CheckParamExceptionSpec - Check if the parameter and return types of the
764/// two functions have equivalent exception specs. This is part of the
765/// assignment and override compatibility check. We do not check the parameters
766/// of parameter function pointers recursively, as no sane programmer would
767/// even be able to write such a function type.
Richard Smith2e321552014-11-12 02:00:47 +0000768bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &NoteID,
769 const FunctionProtoType *Target,
770 SourceLocation TargetLoc,
771 const FunctionProtoType *Source,
772 SourceLocation SourceLoc) {
Alp Toker314cc812014-01-25 16:55:45 +0000773 if (CheckSpecForTypesEquivalent(
774 *this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(),
775 Target->getReturnType(), TargetLoc, Source->getReturnType(),
776 SourceLoc))
Sebastian Redl4915e632009-10-11 09:03:14 +0000777 return true;
778
Sebastian Redla44822f2009-10-14 16:09:29 +0000779 // We shouldn't even be testing this unless the arguments are otherwise
Sebastian Redl4915e632009-10-11 09:03:14 +0000780 // compatible.
Alp Toker9cacbab2014-01-20 20:26:09 +0000781 assert(Target->getNumParams() == Source->getNumParams() &&
Sebastian Redl4915e632009-10-11 09:03:14 +0000782 "Functions have different argument counts.");
Alp Toker9cacbab2014-01-20 20:26:09 +0000783 for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) {
784 if (CheckSpecForTypesEquivalent(
785 *this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(),
786 Target->getParamType(i), TargetLoc, Source->getParamType(i),
787 SourceLoc))
Sebastian Redl4915e632009-10-11 09:03:14 +0000788 return true;
789 }
790 return false;
791}
792
Richard Smith2e321552014-11-12 02:00:47 +0000793bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) {
Sebastian Redl4915e632009-10-11 09:03:14 +0000794 // First we check for applicability.
795 // Target type must be a function, function pointer or function reference.
796 const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType);
Richard Smith2e321552014-11-12 02:00:47 +0000797 if (!ToFunc || ToFunc->hasDependentExceptionSpec())
Sebastian Redl4915e632009-10-11 09:03:14 +0000798 return false;
799
800 // SourceType must be a function or function pointer.
801 const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType());
Richard Smith2e321552014-11-12 02:00:47 +0000802 if (!FromFunc || FromFunc->hasDependentExceptionSpec())
Sebastian Redl4915e632009-10-11 09:03:14 +0000803 return false;
804
805 // Now we've got the correct types on both sides, check their compatibility.
806 // This means that the source of the conversion can only throw a subset of
807 // the exceptions of the target, and any exception specs on arguments or
808 // return types must be equivalent.
Richard Smith2e321552014-11-12 02:00:47 +0000809 //
810 // FIXME: If there is a nested dependent exception specification, we should
811 // not be checking it here. This is fine:
812 // template<typename T> void f() {
813 // void (*p)(void (*) throw(T));
814 // void (*q)(void (*) throw(int)) = p;
815 // }
816 // ... because it might be instantiated with T=int.
Douglas Gregor89336232010-03-29 23:34:08 +0000817 return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs),
818 PDiag(), ToFunc,
819 From->getSourceRange().getBegin(),
Sebastian Redl4915e632009-10-11 09:03:14 +0000820 FromFunc, SourceLocation());
821}
822
823bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
824 const CXXMethodDecl *Old) {
Richard Smith88f45492014-11-22 03:09:05 +0000825 // If the new exception specification hasn't been parsed yet, skip the check.
826 // We'll get called again once it's been parsed.
827 if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
828 EST_Unparsed)
829 return false;
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000830 if (getLangOpts().CPlusPlus11 && isa<CXXDestructorDecl>(New)) {
Sebastian Redl645d9582011-05-20 05:57:18 +0000831 // Don't check uninstantiated template destructors at all. We can only
832 // synthesize correct specs after the template is instantiated.
833 if (New->getParent()->isDependentType())
834 return false;
835 if (New->getParent()->isBeingDefined()) {
836 // The destructor might be updated once the definition is finished. So
837 // remember it and check later.
Richard Smith88f45492014-11-22 03:09:05 +0000838 DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
Sebastian Redl645d9582011-05-20 05:57:18 +0000839 return false;
840 }
Sebastian Redl623ea822011-05-19 05:13:44 +0000841 }
Richard Smith88f45492014-11-22 03:09:05 +0000842 // If the old exception specification hasn't been parsed yet, remember that
843 // we need to perform this check when we get to the end of the outermost
844 // lexically-surrounding class.
845 if (Old->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() ==
846 EST_Unparsed) {
847 DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old));
Richard Smith0b3a4622014-11-13 20:01:57 +0000848 return false;
Richard Smith88f45492014-11-22 03:09:05 +0000849 }
Francois Picheta8032e92011-05-24 02:11:43 +0000850 unsigned DiagID = diag::err_override_exception_spec;
David Blaikiebbafb8a2012-03-11 07:00:24 +0000851 if (getLangOpts().MicrosoftExt)
Richard Smith1b98ccc2014-07-19 01:39:17 +0000852 DiagID = diag::ext_override_exception_spec;
Francois Picheta8032e92011-05-24 02:11:43 +0000853 return CheckExceptionSpecSubset(PDiag(DiagID),
Douglas Gregor89336232010-03-29 23:34:08 +0000854 PDiag(diag::note_overridden_virtual_function),
Sebastian Redl4915e632009-10-11 09:03:14 +0000855 Old->getType()->getAs<FunctionProtoType>(),
856 Old->getLocation(),
857 New->getType()->getAs<FunctionProtoType>(),
858 New->getLocation());
859}
860
Benjamin Kramer642f1732015-07-02 21:03:14 +0000861static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) {
Richard Smithf623c962012-04-17 00:58:00 +0000862 CanThrowResult R = CT_Cannot;
Benjamin Kramer642f1732015-07-02 21:03:14 +0000863 for (const Stmt *SubStmt : E->children()) {
864 R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
865 if (R == CT_Can)
866 break;
867 }
Richard Smithf623c962012-04-17 00:58:00 +0000868 return R;
869}
870
Eli Friedman0423b762013-06-25 01:24:22 +0000871static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
872 assert(D && "Expected decl");
Richard Smithf623c962012-04-17 00:58:00 +0000873
874 // See if we can get a function type from the decl somehow.
875 const ValueDecl *VD = dyn_cast<ValueDecl>(D);
876 if (!VD) // If we have no clue what we're calling, assume the worst.
877 return CT_Can;
878
879 // As an extension, we assume that __attribute__((nothrow)) functions don't
880 // throw.
881 if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
882 return CT_Cannot;
883
884 QualType T = VD->getType();
885 const FunctionProtoType *FT;
886 if ((FT = T->getAs<FunctionProtoType>())) {
887 } else if (const PointerType *PT = T->getAs<PointerType>())
888 FT = PT->getPointeeType()->getAs<FunctionProtoType>();
889 else if (const ReferenceType *RT = T->getAs<ReferenceType>())
890 FT = RT->getPointeeType()->getAs<FunctionProtoType>();
891 else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
892 FT = MT->getPointeeType()->getAs<FunctionProtoType>();
893 else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
894 FT = BT->getPointeeType()->getAs<FunctionProtoType>();
895
896 if (!FT)
897 return CT_Can;
898
899 FT = S.ResolveExceptionSpec(E->getLocStart(), FT);
900 if (!FT)
901 return CT_Can;
902
Richard Smithf623c962012-04-17 00:58:00 +0000903 return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
904}
905
906static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) {
907 if (DC->isTypeDependent())
908 return CT_Dependent;
909
910 if (!DC->getTypeAsWritten()->isReferenceType())
911 return CT_Cannot;
912
913 if (DC->getSubExpr()->isTypeDependent())
914 return CT_Dependent;
915
916 return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot;
917}
918
919static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) {
920 if (DC->isTypeOperand())
921 return CT_Cannot;
922
923 Expr *Op = DC->getExprOperand();
924 if (Op->isTypeDependent())
925 return CT_Dependent;
926
927 const RecordType *RT = Op->getType()->getAs<RecordType>();
928 if (!RT)
929 return CT_Cannot;
930
931 if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
932 return CT_Cannot;
933
934 if (Op->Classify(S.Context).isPRValue())
935 return CT_Cannot;
936
937 return CT_Can;
938}
939
940CanThrowResult Sema::canThrow(const Expr *E) {
941 // C++ [expr.unary.noexcept]p3:
942 // [Can throw] if in a potentially-evaluated context the expression would
943 // contain:
944 switch (E->getStmtClass()) {
945 case Expr::CXXThrowExprClass:
946 // - a potentially evaluated throw-expression
947 return CT_Can;
948
949 case Expr::CXXDynamicCastExprClass: {
950 // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
951 // where T is a reference type, that requires a run-time check
952 CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E));
953 if (CT == CT_Can)
954 return CT;
955 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
956 }
957
958 case Expr::CXXTypeidExprClass:
959 // - a potentially evaluated typeid expression applied to a glvalue
960 // expression whose type is a polymorphic class type
961 return canTypeidThrow(*this, cast<CXXTypeidExpr>(E));
962
963 // - a potentially evaluated call to a function, member function, function
964 // pointer, or member function pointer that does not have a non-throwing
965 // exception-specification
966 case Expr::CallExprClass:
967 case Expr::CXXMemberCallExprClass:
968 case Expr::CXXOperatorCallExprClass:
969 case Expr::UserDefinedLiteralClass: {
970 const CallExpr *CE = cast<CallExpr>(E);
971 CanThrowResult CT;
972 if (E->isTypeDependent())
973 CT = CT_Dependent;
974 else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
975 CT = CT_Cannot;
Eli Friedman5a8738f2013-06-25 01:55:41 +0000976 else if (CE->getCalleeDecl())
Richard Smithf623c962012-04-17 00:58:00 +0000977 CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
Eli Friedman5a8738f2013-06-25 01:55:41 +0000978 else
979 CT = CT_Can;
Richard Smithf623c962012-04-17 00:58:00 +0000980 if (CT == CT_Can)
981 return CT;
982 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
983 }
984
985 case Expr::CXXConstructExprClass:
986 case Expr::CXXTemporaryObjectExprClass: {
987 CanThrowResult CT = canCalleeThrow(*this, E,
988 cast<CXXConstructExpr>(E)->getConstructor());
989 if (CT == CT_Can)
990 return CT;
991 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
992 }
993
994 case Expr::LambdaExprClass: {
995 const LambdaExpr *Lambda = cast<LambdaExpr>(E);
996 CanThrowResult CT = CT_Cannot;
James Y Knight53c76162015-07-17 18:21:37 +0000997 for (LambdaExpr::const_capture_init_iterator
998 Cap = Lambda->capture_init_begin(),
999 CapEnd = Lambda->capture_init_end();
Richard Smithf623c962012-04-17 00:58:00 +00001000 Cap != CapEnd; ++Cap)
1001 CT = mergeCanThrow(CT, canThrow(*Cap));
1002 return CT;
1003 }
1004
1005 case Expr::CXXNewExprClass: {
1006 CanThrowResult CT;
1007 if (E->isTypeDependent())
1008 CT = CT_Dependent;
1009 else
1010 CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew());
1011 if (CT == CT_Can)
1012 return CT;
1013 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1014 }
1015
1016 case Expr::CXXDeleteExprClass: {
1017 CanThrowResult CT;
1018 QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType();
1019 if (DTy.isNull() || DTy->isDependentType()) {
1020 CT = CT_Dependent;
1021 } else {
1022 CT = canCalleeThrow(*this, E,
1023 cast<CXXDeleteExpr>(E)->getOperatorDelete());
1024 if (const RecordType *RT = DTy->getAs<RecordType>()) {
1025 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Eli Friedman0423b762013-06-25 01:24:22 +00001026 const CXXDestructorDecl *DD = RD->getDestructor();
1027 if (DD)
1028 CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD));
Richard Smithf623c962012-04-17 00:58:00 +00001029 }
1030 if (CT == CT_Can)
1031 return CT;
1032 }
1033 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1034 }
1035
1036 case Expr::CXXBindTemporaryExprClass: {
1037 // The bound temporary has to be destroyed again, which might throw.
1038 CanThrowResult CT = canCalleeThrow(*this, E,
1039 cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor());
1040 if (CT == CT_Can)
1041 return CT;
1042 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1043 }
1044
1045 // ObjC message sends are like function calls, but never have exception
1046 // specs.
1047 case Expr::ObjCMessageExprClass:
1048 case Expr::ObjCPropertyRefExprClass:
1049 case Expr::ObjCSubscriptRefExprClass:
1050 return CT_Can;
1051
1052 // All the ObjC literals that are implemented as calls are
1053 // potentially throwing unless we decide to close off that
1054 // possibility.
1055 case Expr::ObjCArrayLiteralClass:
1056 case Expr::ObjCDictionaryLiteralClass:
Patrick Beard0caa3942012-04-19 00:25:12 +00001057 case Expr::ObjCBoxedExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001058 return CT_Can;
1059
1060 // Many other things have subexpressions, so we have to test those.
1061 // Some are simple:
1062 case Expr::ConditionalOperatorClass:
1063 case Expr::CompoundLiteralExprClass:
1064 case Expr::CXXConstCastExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001065 case Expr::CXXReinterpretCastExprClass:
Richard Smithcc1b96d2013-06-12 22:31:48 +00001066 case Expr::CXXStdInitializerListExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001067 case Expr::DesignatedInitExprClass:
Yunzhong Gaocb779302015-06-10 00:27:52 +00001068 case Expr::DesignatedInitUpdateExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001069 case Expr::ExprWithCleanupsClass:
1070 case Expr::ExtVectorElementExprClass:
1071 case Expr::InitListExprClass:
1072 case Expr::MemberExprClass:
1073 case Expr::ObjCIsaExprClass:
1074 case Expr::ObjCIvarRefExprClass:
1075 case Expr::ParenExprClass:
1076 case Expr::ParenListExprClass:
1077 case Expr::ShuffleVectorExprClass:
Hal Finkelc4d7c822013-09-18 03:29:45 +00001078 case Expr::ConvertVectorExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001079 case Expr::VAArgExprClass:
1080 return canSubExprsThrow(*this, E);
1081
1082 // Some might be dependent for other reasons.
1083 case Expr::ArraySubscriptExprClass:
Alexey Bataev1a3320e2015-08-25 14:24:04 +00001084 case Expr::OMPArraySectionExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001085 case Expr::BinaryOperatorClass:
1086 case Expr::CompoundAssignOperatorClass:
1087 case Expr::CStyleCastExprClass:
1088 case Expr::CXXStaticCastExprClass:
1089 case Expr::CXXFunctionalCastExprClass:
1090 case Expr::ImplicitCastExprClass:
1091 case Expr::MaterializeTemporaryExprClass:
1092 case Expr::UnaryOperatorClass: {
1093 CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot;
1094 return mergeCanThrow(CT, canSubExprsThrow(*this, E));
1095 }
1096
1097 // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1098 case Expr::StmtExprClass:
1099 return CT_Can;
1100
Richard Smith852c9db2013-04-20 22:23:05 +00001101 case Expr::CXXDefaultArgExprClass:
1102 return canThrow(cast<CXXDefaultArgExpr>(E)->getExpr());
1103
1104 case Expr::CXXDefaultInitExprClass:
1105 return canThrow(cast<CXXDefaultInitExpr>(E)->getExpr());
1106
Richard Smithf623c962012-04-17 00:58:00 +00001107 case Expr::ChooseExprClass:
1108 if (E->isTypeDependent() || E->isValueDependent())
1109 return CT_Dependent;
Eli Friedman75807f22013-07-20 00:40:58 +00001110 return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr());
Richard Smithf623c962012-04-17 00:58:00 +00001111
1112 case Expr::GenericSelectionExprClass:
1113 if (cast<GenericSelectionExpr>(E)->isResultDependent())
1114 return CT_Dependent;
1115 return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr());
1116
1117 // Some expressions are always dependent.
1118 case Expr::CXXDependentScopeMemberExprClass:
1119 case Expr::CXXUnresolvedConstructExprClass:
1120 case Expr::DependentScopeDeclRefExprClass:
Richard Smith0f0af192014-11-08 05:07:16 +00001121 case Expr::CXXFoldExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001122 return CT_Dependent;
1123
1124 case Expr::AsTypeExprClass:
1125 case Expr::BinaryConditionalOperatorClass:
1126 case Expr::BlockExprClass:
1127 case Expr::CUDAKernelCallExprClass:
1128 case Expr::DeclRefExprClass:
1129 case Expr::ObjCBridgedCastExprClass:
1130 case Expr::ObjCIndirectCopyRestoreExprClass:
1131 case Expr::ObjCProtocolExprClass:
1132 case Expr::ObjCSelectorExprClass:
1133 case Expr::OffsetOfExprClass:
1134 case Expr::PackExpansionExprClass:
1135 case Expr::PseudoObjectExprClass:
1136 case Expr::SubstNonTypeTemplateParmExprClass:
1137 case Expr::SubstNonTypeTemplateParmPackExprClass:
Richard Smithb15fe3a2012-09-12 00:56:43 +00001138 case Expr::FunctionParmPackExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001139 case Expr::UnaryExprOrTypeTraitExprClass:
1140 case Expr::UnresolvedLookupExprClass:
1141 case Expr::UnresolvedMemberExprClass:
Kaelyn Takatae1f49d52014-10-27 18:07:20 +00001142 case Expr::TypoExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001143 // FIXME: Can any of the above throw? If so, when?
1144 return CT_Cannot;
1145
1146 case Expr::AddrLabelExprClass:
1147 case Expr::ArrayTypeTraitExprClass:
1148 case Expr::AtomicExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001149 case Expr::TypeTraitExprClass:
1150 case Expr::CXXBoolLiteralExprClass:
1151 case Expr::CXXNoexceptExprClass:
1152 case Expr::CXXNullPtrLiteralExprClass:
1153 case Expr::CXXPseudoDestructorExprClass:
1154 case Expr::CXXScalarValueInitExprClass:
1155 case Expr::CXXThisExprClass:
1156 case Expr::CXXUuidofExprClass:
1157 case Expr::CharacterLiteralClass:
1158 case Expr::ExpressionTraitExprClass:
1159 case Expr::FloatingLiteralClass:
1160 case Expr::GNUNullExprClass:
1161 case Expr::ImaginaryLiteralClass:
1162 case Expr::ImplicitValueInitExprClass:
1163 case Expr::IntegerLiteralClass:
Yunzhong Gaocb779302015-06-10 00:27:52 +00001164 case Expr::NoInitExprClass:
Richard Smithf623c962012-04-17 00:58:00 +00001165 case Expr::ObjCEncodeExprClass:
1166 case Expr::ObjCStringLiteralClass:
1167 case Expr::ObjCBoolLiteralExprClass:
1168 case Expr::OpaqueValueExprClass:
1169 case Expr::PredefinedExprClass:
1170 case Expr::SizeOfPackExprClass:
1171 case Expr::StringLiteralClass:
Richard Smithf623c962012-04-17 00:58:00 +00001172 // These expressions can never throw.
1173 return CT_Cannot;
1174
John McCall5e77d762013-04-16 07:28:30 +00001175 case Expr::MSPropertyRefExprClass:
1176 llvm_unreachable("Invalid class for expression");
1177
Richard Smithf623c962012-04-17 00:58:00 +00001178#define STMT(CLASS, PARENT) case Expr::CLASS##Class:
1179#define STMT_RANGE(Base, First, Last)
1180#define LAST_STMT_RANGE(BASE, FIRST, LAST)
1181#define EXPR(CLASS, PARENT)
1182#define ABSTRACT_STMT(STMT)
1183#include "clang/AST/StmtNodes.inc"
1184 case Expr::NoStmtClass:
1185 llvm_unreachable("Invalid class for expression");
1186 }
1187 llvm_unreachable("Bogus StmtClass");
1188}
1189
Sebastian Redl4915e632009-10-11 09:03:14 +00001190} // end namespace clang