blob: 38fbea18d790d45f7fd6d4c87a38b431bda38a01 [file] [log] [blame]
Chris Lattner29375652006-12-04 18:06:35 +00001//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner29375652006-12-04 18:06:35 +00007//
8//===----------------------------------------------------------------------===//
James Dennett84053fb2012-06-22 05:14:59 +00009///
10/// \file
11/// \brief Implements semantic analysis for C++ expressions.
12///
13//===----------------------------------------------------------------------===//
Chris Lattner29375652006-12-04 18:06:35 +000014
John McCall83024632010-08-25 22:03:47 +000015#include "clang/Sema/SemaInternal.h"
Kaelyn Takata6c759512014-10-27 18:07:37 +000016#include "TreeTransform.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "TypeLocBuilder.h"
Steve Naroffaac94152007-08-25 14:02:58 +000018#include "clang/AST/ASTContext.h"
Faisal Vali47d9ed42014-05-30 04:39:37 +000019#include "clang/AST/ASTLambda.h"
Douglas Gregor36d1b142009-10-06 17:59:45 +000020#include "clang/AST/CXXInheritance.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "clang/AST/CharUnits.h"
John McCallde6836a2010-08-24 07:21:54 +000022#include "clang/AST/DeclObjC.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000023#include "clang/AST/ExprCXX.h"
Fariborz Jahanian1d446082010-06-16 18:56:04 +000024#include "clang/AST/ExprObjC.h"
Faisal Valia17d19f2013-11-07 05:17:06 +000025#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregorb1dd23f2010-02-24 22:38:50 +000026#include "clang/AST/TypeLoc.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000027#include "clang/Basic/PartialDiagnostic.h"
Sebastian Redlfaf68082008-12-03 20:26:15 +000028#include "clang/Basic/TargetInfo.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000029#include "clang/Lex/Preprocessor.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000030#include "clang/Sema/DeclSpec.h"
31#include "clang/Sema/Initialization.h"
32#include "clang/Sema/Lookup.h"
33#include "clang/Sema/ParsedTemplate.h"
34#include "clang/Sema/Scope.h"
35#include "clang/Sema/ScopeInfo.h"
Faisal Valia17d19f2013-11-07 05:17:06 +000036#include "clang/Sema/SemaLambda.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000037#include "clang/Sema/TemplateDeduction.h"
Sebastian Redlb8fc4772012-02-16 12:59:47 +000038#include "llvm/ADT/APInt.h"
Douglas Gregor55297ac2008-12-23 00:26:44 +000039#include "llvm/ADT/STLExtras.h"
Chandler Carruth8b0cf1d2011-05-01 07:23:17 +000040#include "llvm/Support/ErrorHandling.h"
Chris Lattner29375652006-12-04 18:06:35 +000041using namespace clang;
John McCall19c1bfd2010-08-25 05:32:35 +000042using namespace sema;
Chris Lattner29375652006-12-04 18:06:35 +000043
Richard Smith7447af42013-03-26 01:15:19 +000044/// \brief Handle the result of the special case name lookup for inheriting
45/// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
46/// constructor names in member using declarations, even if 'X' is not the
47/// name of the corresponding type.
48ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,
49 SourceLocation NameLoc,
50 IdentifierInfo &Name) {
51 NestedNameSpecifier *NNS = SS.getScopeRep();
52
53 // Convert the nested-name-specifier into a type.
54 QualType Type;
55 switch (NNS->getKind()) {
56 case NestedNameSpecifier::TypeSpec:
57 case NestedNameSpecifier::TypeSpecWithTemplate:
58 Type = QualType(NNS->getAsType(), 0);
59 break;
60
61 case NestedNameSpecifier::Identifier:
62 // Strip off the last layer of the nested-name-specifier and build a
63 // typename type for it.
64 assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
65 Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
66 NNS->getAsIdentifier());
67 break;
68
69 case NestedNameSpecifier::Global:
Nikola Smiljanic67860242014-09-26 00:28:20 +000070 case NestedNameSpecifier::Super:
Richard Smith7447af42013-03-26 01:15:19 +000071 case NestedNameSpecifier::Namespace:
72 case NestedNameSpecifier::NamespaceAlias:
73 llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
74 }
75
76 // This reference to the type is located entirely at the location of the
77 // final identifier in the qualified-id.
78 return CreateParsedType(Type,
79 Context.getTrivialTypeSourceInfo(Type, NameLoc));
80}
81
John McCallba7bf592010-08-24 05:47:05 +000082ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +000083 IdentifierInfo &II,
John McCallba7bf592010-08-24 05:47:05 +000084 SourceLocation NameLoc,
85 Scope *S, CXXScopeSpec &SS,
86 ParsedType ObjectTypePtr,
87 bool EnteringContext) {
Douglas Gregorfe17d252010-02-16 19:09:40 +000088 // Determine where to perform name lookup.
89
90 // FIXME: This area of the standard is very messy, and the current
91 // wording is rather unclear about which scopes we search for the
92 // destructor name; see core issues 399 and 555. Issue 399 in
93 // particular shows where the current description of destructor name
94 // lookup is completely out of line with existing practice, e.g.,
95 // this appears to be ill-formed:
96 //
97 // namespace N {
98 // template <typename T> struct S {
99 // ~S();
100 // };
101 // }
102 //
103 // void f(N::S<int>* s) {
104 // s->N::S<int>::~S();
105 // }
106 //
Douglas Gregor46841e12010-02-23 00:15:22 +0000107 // See also PR6358 and PR6359.
Sebastian Redla771d222010-07-07 23:17:38 +0000108 // For this reason, we're currently only doing the C++03 version of this
109 // code; the C++0x version has to wait until we get a proper spec.
Douglas Gregorfe17d252010-02-16 19:09:40 +0000110 QualType SearchType;
Craig Topperc3ec1492014-05-26 06:22:03 +0000111 DeclContext *LookupCtx = nullptr;
Douglas Gregorfe17d252010-02-16 19:09:40 +0000112 bool isDependent = false;
113 bool LookInScope = false;
114
Richard Smith64e033f2015-01-15 00:48:52 +0000115 if (SS.isInvalid())
116 return ParsedType();
117
Douglas Gregorfe17d252010-02-16 19:09:40 +0000118 // If we have an object type, it's because we are in a
119 // pseudo-destructor-expression or a member access expression, and
120 // we know what type we're looking for.
121 if (ObjectTypePtr)
122 SearchType = GetTypeFromParser(ObjectTypePtr);
123
124 if (SS.isSet()) {
Aaron Ballman4a979672014-01-03 13:56:08 +0000125 NestedNameSpecifier *NNS = SS.getScopeRep();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000126
Douglas Gregor46841e12010-02-23 00:15:22 +0000127 bool AlreadySearched = false;
128 bool LookAtPrefix = true;
David Majnemere37a6ce2014-05-21 20:19:59 +0000129 // C++11 [basic.lookup.qual]p6:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000130 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
Sebastian Redla771d222010-07-07 23:17:38 +0000131 // the type-names are looked up as types in the scope designated by the
David Majnemere37a6ce2014-05-21 20:19:59 +0000132 // nested-name-specifier. Similarly, in a qualified-id of the form:
NAKAMURA Takumi7c288862011-01-27 07:09:49 +0000133 //
David Majnemere37a6ce2014-05-21 20:19:59 +0000134 // nested-name-specifier[opt] class-name :: ~ class-name
Sebastian Redla771d222010-07-07 23:17:38 +0000135 //
David Majnemere37a6ce2014-05-21 20:19:59 +0000136 // the second class-name is looked up in the same scope as the first.
Douglas Gregorfe17d252010-02-16 19:09:40 +0000137 //
David Majnemere37a6ce2014-05-21 20:19:59 +0000138 // Here, we determine whether the code below is permitted to look at the
139 // prefix of the nested-name-specifier.
Sebastian Redla771d222010-07-07 23:17:38 +0000140 DeclContext *DC = computeDeclContext(SS, EnteringContext);
141 if (DC && DC->isFileContext()) {
142 AlreadySearched = true;
143 LookupCtx = DC;
144 isDependent = false;
David Majnemere37a6ce2014-05-21 20:19:59 +0000145 } else if (DC && isa<CXXRecordDecl>(DC)) {
Sebastian Redla771d222010-07-07 23:17:38 +0000146 LookAtPrefix = false;
David Majnemere37a6ce2014-05-21 20:19:59 +0000147 LookInScope = true;
148 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000149
Sebastian Redla771d222010-07-07 23:17:38 +0000150 // The second case from the C++03 rules quoted further above.
Craig Topperc3ec1492014-05-26 06:22:03 +0000151 NestedNameSpecifier *Prefix = nullptr;
Douglas Gregor46841e12010-02-23 00:15:22 +0000152 if (AlreadySearched) {
153 // Nothing left to do.
154 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
155 CXXScopeSpec PrefixSS;
Douglas Gregor10176412011-02-25 16:07:42 +0000156 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
Douglas Gregor46841e12010-02-23 00:15:22 +0000157 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
158 isDependent = isDependentScopeSpecifier(PrefixSS);
Douglas Gregor46841e12010-02-23 00:15:22 +0000159 } else if (ObjectTypePtr) {
Douglas Gregorfe17d252010-02-16 19:09:40 +0000160 LookupCtx = computeDeclContext(SearchType);
161 isDependent = SearchType->isDependentType();
162 } else {
163 LookupCtx = computeDeclContext(SS, EnteringContext);
Douglas Gregor46841e12010-02-23 00:15:22 +0000164 isDependent = LookupCtx && LookupCtx->isDependentContext();
Douglas Gregorfe17d252010-02-16 19:09:40 +0000165 }
Douglas Gregorfe17d252010-02-16 19:09:40 +0000166 } else if (ObjectTypePtr) {
167 // C++ [basic.lookup.classref]p3:
168 // If the unqualified-id is ~type-name, the type-name is looked up
169 // in the context of the entire postfix-expression. If the type T
170 // of the object expression is of a class type C, the type-name is
171 // also looked up in the scope of class C. At least one of the
172 // lookups shall find a name that refers to (possibly
173 // cv-qualified) T.
174 LookupCtx = computeDeclContext(SearchType);
175 isDependent = SearchType->isDependentType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000176 assert((isDependent || !SearchType->isIncompleteType()) &&
Douglas Gregorfe17d252010-02-16 19:09:40 +0000177 "Caller should have completed object type");
178
179 LookInScope = true;
180 } else {
181 // Perform lookup into the current scope (only).
182 LookInScope = true;
183 }
184
Craig Topperc3ec1492014-05-26 06:22:03 +0000185 TypeDecl *NonMatchingTypeDecl = nullptr;
Douglas Gregorfe17d252010-02-16 19:09:40 +0000186 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
187 for (unsigned Step = 0; Step != 2; ++Step) {
188 // Look for the name first in the computed lookup context (if we
Douglas Gregor4cf85a72011-03-04 22:32:08 +0000189 // have one) and, if that fails to find a match, in the scope (if
Douglas Gregorfe17d252010-02-16 19:09:40 +0000190 // we're allowed to look there).
191 Found.clear();
192 if (Step == 0 && LookupCtx)
193 LookupQualifiedName(Found, LookupCtx);
Douglas Gregor678f90d2010-02-25 01:56:36 +0000194 else if (Step == 1 && LookInScope && S)
Douglas Gregorfe17d252010-02-16 19:09:40 +0000195 LookupName(Found, S);
196 else
197 continue;
198
199 // FIXME: Should we be suppressing ambiguities here?
200 if (Found.isAmbiguous())
John McCallba7bf592010-08-24 05:47:05 +0000201 return ParsedType();
Douglas Gregorfe17d252010-02-16 19:09:40 +0000202
203 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
204 QualType T = Context.getTypeDeclType(Type);
Nico Weber83a63872014-11-12 04:33:52 +0000205 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
Douglas Gregorfe17d252010-02-16 19:09:40 +0000206
207 if (SearchType.isNull() || SearchType->isDependentType() ||
208 Context.hasSameUnqualifiedType(T, SearchType)) {
209 // We found our type!
210
Richard Smithc278c002014-01-22 00:30:17 +0000211 return CreateParsedType(T,
212 Context.getTrivialTypeSourceInfo(T, NameLoc));
Douglas Gregorfe17d252010-02-16 19:09:40 +0000213 }
John Wiegleyb4a9e512011-03-08 08:13:22 +0000214
Douglas Gregor4cf85a72011-03-04 22:32:08 +0000215 if (!SearchType.isNull())
216 NonMatchingTypeDecl = Type;
Douglas Gregorfe17d252010-02-16 19:09:40 +0000217 }
218
219 // If the name that we found is a class template name, and it is
220 // the same name as the template name in the last part of the
221 // nested-name-specifier (if present) or the object type, then
222 // this is the destructor for that class.
223 // FIXME: This is a workaround until we get real drafting for core
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000224 // issue 399, for which there isn't even an obvious direction.
Douglas Gregorfe17d252010-02-16 19:09:40 +0000225 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
226 QualType MemberOfType;
227 if (SS.isSet()) {
228 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
229 // Figure out the type of the context, if it has one.
John McCalle78aac42010-03-10 03:28:59 +0000230 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
231 MemberOfType = Context.getTypeDeclType(Record);
Douglas Gregorfe17d252010-02-16 19:09:40 +0000232 }
233 }
234 if (MemberOfType.isNull())
235 MemberOfType = SearchType;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000236
Douglas Gregorfe17d252010-02-16 19:09:40 +0000237 if (MemberOfType.isNull())
238 continue;
239
240 // We're referring into a class template specialization. If the
241 // class template we found is the same as the template being
242 // specialized, we found what we are looking for.
243 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
244 if (ClassTemplateSpecializationDecl *Spec
245 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
246 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
247 Template->getCanonicalDecl())
Richard Smithc278c002014-01-22 00:30:17 +0000248 return CreateParsedType(
249 MemberOfType,
250 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
Douglas Gregorfe17d252010-02-16 19:09:40 +0000251 }
252
253 continue;
254 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000255
Douglas Gregorfe17d252010-02-16 19:09:40 +0000256 // We're referring to an unresolved class template
257 // specialization. Determine whether we class template we found
258 // is the same as the template being specialized or, if we don't
259 // know which template is being specialized, that it at least
260 // has the same name.
261 if (const TemplateSpecializationType *SpecType
262 = MemberOfType->getAs<TemplateSpecializationType>()) {
263 TemplateName SpecName = SpecType->getTemplateName();
264
265 // The class template we found is the same template being
266 // specialized.
267 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
268 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
Richard Smithc278c002014-01-22 00:30:17 +0000269 return CreateParsedType(
270 MemberOfType,
271 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
Douglas Gregorfe17d252010-02-16 19:09:40 +0000272
273 continue;
274 }
275
276 // The class template we found has the same name as the
277 // (dependent) template name being specialized.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000278 if (DependentTemplateName *DepTemplate
Douglas Gregorfe17d252010-02-16 19:09:40 +0000279 = SpecName.getAsDependentTemplateName()) {
280 if (DepTemplate->isIdentifier() &&
281 DepTemplate->getIdentifier() == Template->getIdentifier())
Richard Smithc278c002014-01-22 00:30:17 +0000282 return CreateParsedType(
283 MemberOfType,
284 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
Douglas Gregorfe17d252010-02-16 19:09:40 +0000285
286 continue;
287 }
288 }
289 }
290 }
291
292 if (isDependent) {
293 // We didn't find our type, but that's okay: it's dependent
294 // anyway.
Douglas Gregor9cbc22b2011-02-28 22:42:13 +0000295
296 // FIXME: What if we have no nested-name-specifier?
297 QualType T = CheckTypenameType(ETK_None, SourceLocation(),
298 SS.getWithLocInContext(Context),
299 II, NameLoc);
John McCallba7bf592010-08-24 05:47:05 +0000300 return ParsedType::make(T);
Douglas Gregorfe17d252010-02-16 19:09:40 +0000301 }
302
Douglas Gregor4cf85a72011-03-04 22:32:08 +0000303 if (NonMatchingTypeDecl) {
304 QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
305 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
306 << T << SearchType;
307 Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
308 << T;
309 } else if (ObjectTypePtr)
310 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000311 << &II;
David Blaikie5e026f52013-03-20 17:42:13 +0000312 else {
313 SemaDiagnosticBuilder DtorDiag = Diag(NameLoc,
314 diag::err_destructor_class_name);
315 if (S) {
Ted Kremenekc37877d2013-10-08 17:08:03 +0000316 const DeclContext *Ctx = S->getEntity();
David Blaikie5e026f52013-03-20 17:42:13 +0000317 if (const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
318 DtorDiag << FixItHint::CreateReplacement(SourceRange(NameLoc),
319 Class->getNameAsString());
320 }
321 }
Douglas Gregorfe17d252010-02-16 19:09:40 +0000322
John McCallba7bf592010-08-24 05:47:05 +0000323 return ParsedType();
Douglas Gregorfe17d252010-02-16 19:09:40 +0000324}
325
David Blaikieecd8a942011-12-08 16:13:53 +0000326ParsedType Sema::getDestructorType(const DeclSpec& DS, ParsedType ObjectType) {
David Blaikie08608f62011-12-12 04:13:55 +0000327 if (DS.getTypeSpecType() == DeclSpec::TST_error || !ObjectType)
David Blaikieecd8a942011-12-08 16:13:53 +0000328 return ParsedType();
329 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype
330 && "only get destructor types from declspecs");
331 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
332 QualType SearchType = GetTypeFromParser(ObjectType);
333 if (SearchType->isDependentType() || Context.hasSameUnqualifiedType(SearchType, T)) {
334 return ParsedType::make(T);
335 }
336
337 Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
338 << T << SearchType;
339 return ParsedType();
340}
341
Richard Smithd091dc12013-12-05 00:58:33 +0000342bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
343 const UnqualifiedId &Name) {
344 assert(Name.getKind() == UnqualifiedId::IK_LiteralOperatorId);
345
346 if (!SS.isValid())
347 return false;
348
349 switch (SS.getScopeRep()->getKind()) {
350 case NestedNameSpecifier::Identifier:
351 case NestedNameSpecifier::TypeSpec:
352 case NestedNameSpecifier::TypeSpecWithTemplate:
353 // Per C++11 [over.literal]p2, literal operators can only be declared at
354 // namespace scope. Therefore, this unqualified-id cannot name anything.
355 // Reject it early, because we have no AST representation for this in the
356 // case where the scope is dependent.
357 Diag(Name.getLocStart(), diag::err_literal_operator_id_outside_namespace)
358 << SS.getScopeRep();
359 return true;
360
361 case NestedNameSpecifier::Global:
Nikola Smiljanic67860242014-09-26 00:28:20 +0000362 case NestedNameSpecifier::Super:
Richard Smithd091dc12013-12-05 00:58:33 +0000363 case NestedNameSpecifier::Namespace:
364 case NestedNameSpecifier::NamespaceAlias:
365 return false;
366 }
367
368 llvm_unreachable("unknown nested name specifier kind");
369}
370
Douglas Gregor9da64192010-04-26 22:37:10 +0000371/// \brief Build a C++ typeid expression with a type operand.
John McCalldadc5752010-08-24 06:29:42 +0000372ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4c7c1092010-09-08 23:14:30 +0000373 SourceLocation TypeidLoc,
374 TypeSourceInfo *Operand,
375 SourceLocation RParenLoc) {
Douglas Gregor9da64192010-04-26 22:37:10 +0000376 // C++ [expr.typeid]p4:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000377 // The top-level cv-qualifiers of the lvalue expression or the type-id
Douglas Gregor9da64192010-04-26 22:37:10 +0000378 // that is the operand of typeid are always ignored.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000379 // If the type of the type-id is a class type or a reference to a class
Douglas Gregor9da64192010-04-26 22:37:10 +0000380 // type, the class shall be completely-defined.
Douglas Gregor876cec22010-06-02 06:16:02 +0000381 Qualifiers Quals;
382 QualType T
383 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
384 Quals);
Douglas Gregor9da64192010-04-26 22:37:10 +0000385 if (T->getAs<RecordType>() &&
386 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
387 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000388
David Majnemer6f3150a2014-11-21 21:09:12 +0000389 if (T->isVariablyModifiedType())
390 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
391
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000392 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
393 SourceRange(TypeidLoc, RParenLoc));
Douglas Gregor9da64192010-04-26 22:37:10 +0000394}
395
396/// \brief Build a C++ typeid expression with an expression operand.
John McCalldadc5752010-08-24 06:29:42 +0000397ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4c7c1092010-09-08 23:14:30 +0000398 SourceLocation TypeidLoc,
399 Expr *E,
400 SourceLocation RParenLoc) {
Aaron Ballman6c93b3e2014-12-17 21:57:17 +0000401 bool WasEvaluated = false;
Douglas Gregor9da64192010-04-26 22:37:10 +0000402 if (E && !E->isTypeDependent()) {
John McCall50a2c2c2011-10-11 23:14:30 +0000403 if (E->getType()->isPlaceholderType()) {
404 ExprResult result = CheckPlaceholderExpr(E);
405 if (result.isInvalid()) return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000406 E = result.get();
John McCall50a2c2c2011-10-11 23:14:30 +0000407 }
408
Douglas Gregor9da64192010-04-26 22:37:10 +0000409 QualType T = E->getType();
410 if (const RecordType *RecordT = T->getAs<RecordType>()) {
411 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
412 // C++ [expr.typeid]p3:
413 // [...] If the type of the expression is a class type, the class
414 // shall be completely-defined.
415 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
416 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000417
Douglas Gregor9da64192010-04-26 22:37:10 +0000418 // C++ [expr.typeid]p3:
Sebastian Redlc57d34b2010-07-20 04:20:21 +0000419 // When typeid is applied to an expression other than an glvalue of a
Douglas Gregor9da64192010-04-26 22:37:10 +0000420 // polymorphic class type [...] [the] expression is an unevaluated
421 // operand. [...]
Richard Smithef8bf432012-08-13 20:08:14 +0000422 if (RecordD->isPolymorphic() && E->isGLValue()) {
Eli Friedman456f0182012-01-20 01:26:23 +0000423 // The subexpression is potentially evaluated; switch the context
424 // and recheck the subexpression.
Benjamin Kramerd81108f2012-11-14 15:08:31 +0000425 ExprResult Result = TransformToPotentiallyEvaluated(E);
Eli Friedman456f0182012-01-20 01:26:23 +0000426 if (Result.isInvalid()) return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000427 E = Result.get();
Douglas Gregor88d292c2010-05-13 16:44:06 +0000428
429 // We require a vtable to query the type at run time.
430 MarkVTableUsed(TypeidLoc, RecordD);
Aaron Ballman6c93b3e2014-12-17 21:57:17 +0000431 WasEvaluated = true;
Douglas Gregor88d292c2010-05-13 16:44:06 +0000432 }
Douglas Gregor9da64192010-04-26 22:37:10 +0000433 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000434
Douglas Gregor9da64192010-04-26 22:37:10 +0000435 // C++ [expr.typeid]p4:
436 // [...] If the type of the type-id is a reference to a possibly
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000437 // cv-qualified type, the result of the typeid expression refers to a
438 // std::type_info object representing the cv-unqualified referenced
Douglas Gregor9da64192010-04-26 22:37:10 +0000439 // type.
Douglas Gregor876cec22010-06-02 06:16:02 +0000440 Qualifiers Quals;
441 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
442 if (!Context.hasSameType(T, UnqualT)) {
443 T = UnqualT;
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000444 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();
Douglas Gregor9da64192010-04-26 22:37:10 +0000445 }
446 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000447
David Majnemer6f3150a2014-11-21 21:09:12 +0000448 if (E->getType()->isVariablyModifiedType())
449 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)
450 << E->getType());
Aaron Ballman6c93b3e2014-12-17 21:57:17 +0000451 else if (ActiveTemplateInstantiations.empty() &&
452 E->HasSideEffects(Context, WasEvaluated)) {
453 // The expression operand for typeid is in an unevaluated expression
454 // context, so side effects could result in unintended consequences.
455 Diag(E->getExprLoc(), WasEvaluated
456 ? diag::warn_side_effects_typeid
457 : diag::warn_side_effects_unevaluated_context);
458 }
David Majnemer6f3150a2014-11-21 21:09:12 +0000459
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000460 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,
461 SourceRange(TypeidLoc, RParenLoc));
Douglas Gregor9da64192010-04-26 22:37:10 +0000462}
463
464/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
John McCalldadc5752010-08-24 06:29:42 +0000465ExprResult
Sebastian Redlc4704762008-11-11 11:37:55 +0000466Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
467 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
Douglas Gregor9da64192010-04-26 22:37:10 +0000468 // Find the std::type_info type.
Sebastian Redl7ac97412011-03-31 19:29:24 +0000469 if (!getStdNamespace())
Sebastian Redl6d4256c2009-03-15 17:47:39 +0000470 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
Argyrios Kyrtzidisc7148c92009-08-19 01:28:28 +0000471
Douglas Gregor4c7c1092010-09-08 23:14:30 +0000472 if (!CXXTypeInfoDecl) {
473 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
474 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
475 LookupQualifiedName(R, getStdNamespace());
476 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
Nico Weber5f968832012-06-19 23:58:27 +0000477 // Microsoft's typeinfo doesn't have type_info in std but in the global
478 // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
Alp Tokerbfa39342014-01-14 12:51:41 +0000479 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
Nico Weber5f968832012-06-19 23:58:27 +0000480 LookupQualifiedName(R, Context.getTranslationUnitDecl());
481 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
482 }
Douglas Gregor4c7c1092010-09-08 23:14:30 +0000483 if (!CXXTypeInfoDecl)
484 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
485 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000486
Nico Weber1b7f39d2012-05-20 01:27:21 +0000487 if (!getLangOpts().RTTI) {
488 return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
489 }
490
Douglas Gregor4c7c1092010-09-08 23:14:30 +0000491 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000492
Douglas Gregor9da64192010-04-26 22:37:10 +0000493 if (isType) {
494 // The operand is a type; handle it as such.
Craig Topperc3ec1492014-05-26 06:22:03 +0000495 TypeSourceInfo *TInfo = nullptr;
John McCallba7bf592010-08-24 05:47:05 +0000496 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
497 &TInfo);
Douglas Gregor9da64192010-04-26 22:37:10 +0000498 if (T.isNull())
499 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000500
Douglas Gregor9da64192010-04-26 22:37:10 +0000501 if (!TInfo)
502 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
Sebastian Redlc4704762008-11-11 11:37:55 +0000503
Douglas Gregor9da64192010-04-26 22:37:10 +0000504 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
Douglas Gregor0b6a6242009-06-22 20:57:11 +0000505 }
Mike Stump11289f42009-09-09 15:08:12 +0000506
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000507 // The operand is an expression.
John McCallb268a282010-08-23 23:25:46 +0000508 return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
Sebastian Redlc4704762008-11-11 11:37:55 +0000509}
510
Francois Pichet9f4f2072010-09-08 12:20:18 +0000511/// \brief Build a Microsoft __uuidof expression with a type operand.
512ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
513 SourceLocation TypeidLoc,
514 TypeSourceInfo *Operand,
515 SourceLocation RParenLoc) {
Francois Pichetb7577652010-12-27 01:32:00 +0000516 if (!Operand->getType()->isDependentType()) {
David Majnemer59c0ec22013-09-07 06:59:46 +0000517 bool HasMultipleGUIDs = false;
518 if (!CXXUuidofExpr::GetUuidAttrOfType(Operand->getType(),
519 &HasMultipleGUIDs)) {
520 if (HasMultipleGUIDs)
521 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
522 else
523 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
524 }
Francois Pichetb7577652010-12-27 01:32:00 +0000525 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000526
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000527 return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), Operand,
528 SourceRange(TypeidLoc, RParenLoc));
Francois Pichet9f4f2072010-09-08 12:20:18 +0000529}
530
531/// \brief Build a Microsoft __uuidof expression with an expression operand.
532ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
533 SourceLocation TypeidLoc,
534 Expr *E,
535 SourceLocation RParenLoc) {
Francois Pichetb7577652010-12-27 01:32:00 +0000536 if (!E->getType()->isDependentType()) {
David Majnemer59c0ec22013-09-07 06:59:46 +0000537 bool HasMultipleGUIDs = false;
538 if (!CXXUuidofExpr::GetUuidAttrOfType(E->getType(), &HasMultipleGUIDs) &&
539 !E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
540 if (HasMultipleGUIDs)
541 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
542 else
543 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
544 }
Francois Pichetb7577652010-12-27 01:32:00 +0000545 }
David Majnemer59c0ec22013-09-07 06:59:46 +0000546
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000547 return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), E,
548 SourceRange(TypeidLoc, RParenLoc));
Francois Pichet9f4f2072010-09-08 12:20:18 +0000549}
550
551/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
552ExprResult
553Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
554 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000555 // If MSVCGuidDecl has not been cached, do the lookup.
Francois Pichet9f4f2072010-09-08 12:20:18 +0000556 if (!MSVCGuidDecl) {
557 IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
558 LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
559 LookupQualifiedName(R, Context.getTranslationUnitDecl());
560 MSVCGuidDecl = R.getAsSingle<RecordDecl>();
561 if (!MSVCGuidDecl)
562 return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000563 }
564
Francois Pichet9f4f2072010-09-08 12:20:18 +0000565 QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000566
Francois Pichet9f4f2072010-09-08 12:20:18 +0000567 if (isType) {
568 // The operand is a type; handle it as such.
Craig Topperc3ec1492014-05-26 06:22:03 +0000569 TypeSourceInfo *TInfo = nullptr;
Francois Pichet9f4f2072010-09-08 12:20:18 +0000570 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
571 &TInfo);
572 if (T.isNull())
573 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000574
Francois Pichet9f4f2072010-09-08 12:20:18 +0000575 if (!TInfo)
576 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
577
578 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
579 }
580
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000581 // The operand is an expression.
Francois Pichet9f4f2072010-09-08 12:20:18 +0000582 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
583}
584
Steve Naroff66356bd2007-09-16 14:56:35 +0000585/// ActOnCXXBoolLiteral - Parse {true,false} literals.
John McCalldadc5752010-08-24 06:29:42 +0000586ExprResult
Steve Naroff66356bd2007-09-16 14:56:35 +0000587Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
Douglas Gregor08d918a2008-10-24 15:36:09 +0000588 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
Bill Wendlingbf313b02007-02-13 20:09:46 +0000589 "Unknown C++ Boolean value!");
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000590 return new (Context)
591 CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);
Bill Wendling4073ed52007-02-13 01:51:42 +0000592}
Chris Lattnerb7e656b2008-02-26 00:51:44 +0000593
Sebastian Redl576fd422009-05-10 18:38:11 +0000594/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
John McCalldadc5752010-08-24 06:29:42 +0000595ExprResult
Sebastian Redl576fd422009-05-10 18:38:11 +0000596Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000597 return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
Sebastian Redl576fd422009-05-10 18:38:11 +0000598}
599
Chris Lattnerb7e656b2008-02-26 00:51:44 +0000600/// ActOnCXXThrow - Parse throw expressions.
John McCalldadc5752010-08-24 06:29:42 +0000601ExprResult
Douglas Gregor53e191ed2011-07-06 22:04:06 +0000602Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {
603 bool IsThrownVarInScope = false;
604 if (Ex) {
605 // C++0x [class.copymove]p31:
Nico Weberb58e51c2014-11-19 05:21:39 +0000606 // When certain criteria are met, an implementation is allowed to omit the
Douglas Gregor53e191ed2011-07-06 22:04:06 +0000607 // copy/move construction of a class object [...]
608 //
David Blaikie3c8c46e2014-11-19 05:48:40 +0000609 // - in a throw-expression, when the operand is the name of a
Douglas Gregor53e191ed2011-07-06 22:04:06 +0000610 // non-volatile automatic object (other than a function or catch-
Nico Weberb58e51c2014-11-19 05:21:39 +0000611 // clause parameter) whose scope does not extend beyond the end of the
David Blaikie3c8c46e2014-11-19 05:48:40 +0000612 // innermost enclosing try-block (if there is one), the copy/move
613 // operation from the operand to the exception object (15.1) can be
614 // omitted by constructing the automatic object directly into the
Douglas Gregor53e191ed2011-07-06 22:04:06 +0000615 // exception object
616 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
617 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
618 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
619 for( ; S; S = S->getParent()) {
620 if (S->isDeclScope(Var)) {
621 IsThrownVarInScope = true;
622 break;
623 }
624
625 if (S->getFlags() &
626 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
627 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
628 Scope::TryScope))
629 break;
630 }
631 }
632 }
633 }
634
635 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
636}
637
638ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
639 bool IsThrownVarInScope) {
Anders Carlssond99dbcc2011-02-23 03:46:46 +0000640 // Don't report an error if 'throw' is used in system headers.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000641 if (!getLangOpts().CXXExceptions &&
Anders Carlssond99dbcc2011-02-23 03:46:46 +0000642 !getSourceManager().isInSystemHeader(OpLoc))
Anders Carlssonb94ad3e2011-02-19 21:53:09 +0000643 Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
Alexander Musmana8e9d2e2014-06-03 10:16:47 +0000644
645 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
646 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
647
John Wiegley01296292011-04-08 18:41:53 +0000648 if (Ex && !Ex->isTypeDependent()) {
David Majnemerba3e5ec2015-03-13 18:26:17 +0000649 QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
650 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
John Wiegley01296292011-04-08 18:41:53 +0000651 return ExprError();
David Majnemerba3e5ec2015-03-13 18:26:17 +0000652
653 // Initialize the exception result. This implicitly weeds out
654 // abstract types or types with inaccessible copy constructors.
655
656 // C++0x [class.copymove]p31:
657 // When certain criteria are met, an implementation is allowed to omit the
658 // copy/move construction of a class object [...]
659 //
660 // - in a throw-expression, when the operand is the name of a
661 // non-volatile automatic object (other than a function or
662 // catch-clause
663 // parameter) whose scope does not extend beyond the end of the
664 // innermost enclosing try-block (if there is one), the copy/move
665 // operation from the operand to the exception object (15.1) can be
666 // omitted by constructing the automatic object directly into the
667 // exception object
668 const VarDecl *NRVOVariable = nullptr;
669 if (IsThrownVarInScope)
670 NRVOVariable = getCopyElisionCandidate(QualType(), Ex, false);
671
672 InitializedEntity Entity = InitializedEntity::InitializeException(
673 OpLoc, ExceptionObjectTy,
674 /*NRVO=*/NRVOVariable != nullptr);
675 ExprResult Res = PerformMoveOrCopyInitialization(
676 Entity, NRVOVariable, QualType(), Ex, IsThrownVarInScope);
677 if (Res.isInvalid())
678 return ExprError();
679 Ex = Res.get();
John Wiegley01296292011-04-08 18:41:53 +0000680 }
David Majnemerba3e5ec2015-03-13 18:26:17 +0000681
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000682 return new (Context)
683 CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);
Sebastian Redl4de47b42009-04-27 20:27:31 +0000684}
685
David Majnemere7a818f2015-03-06 18:53:55 +0000686static void
687collectPublicBases(CXXRecordDecl *RD,
688 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
689 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
690 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
691 bool ParentIsPublic) {
692 for (const CXXBaseSpecifier &BS : RD->bases()) {
693 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
694 bool NewSubobject;
695 // Virtual bases constitute the same subobject. Non-virtual bases are
696 // always distinct subobjects.
697 if (BS.isVirtual())
698 NewSubobject = VBases.insert(BaseDecl).second;
699 else
700 NewSubobject = true;
701
702 if (NewSubobject)
703 ++SubobjectsSeen[BaseDecl];
704
705 // Only add subobjects which have public access throughout the entire chain.
706 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;
707 if (PublicPath)
708 PublicSubobjectsSeen.insert(BaseDecl);
709
710 // Recurse on to each base subobject.
711 collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,
712 PublicPath);
713 }
714}
715
716static void getUnambiguousPublicSubobjects(
717 CXXRecordDecl *RD, llvm::SmallVectorImpl<CXXRecordDecl *> &Objects) {
718 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
719 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
720 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
721 SubobjectsSeen[RD] = 1;
722 PublicSubobjectsSeen.insert(RD);
723 collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,
724 /*ParentIsPublic=*/true);
725
726 for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
727 // Skip ambiguous objects.
728 if (SubobjectsSeen[PublicSubobject] > 1)
729 continue;
730
731 Objects.push_back(PublicSubobject);
732 }
733}
734
Sebastian Redl4de47b42009-04-27 20:27:31 +0000735/// CheckCXXThrowOperand - Validate the operand of a throw.
David Majnemerba3e5ec2015-03-13 18:26:17 +0000736bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
737 QualType ExceptionObjectTy, Expr *E) {
Sebastian Redl4de47b42009-04-27 20:27:31 +0000738 // If the type of the exception would be an incomplete type or a pointer
739 // to an incomplete type other than (cv) void the program is ill-formed.
David Majnemerd09a51c2015-03-03 01:50:05 +0000740 QualType Ty = ExceptionObjectTy;
John McCall2e6567a2010-04-22 01:10:34 +0000741 bool isPointer = false;
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000742 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
Sebastian Redl4de47b42009-04-27 20:27:31 +0000743 Ty = Ptr->getPointeeType();
John McCall2e6567a2010-04-22 01:10:34 +0000744 isPointer = true;
Sebastian Redl4de47b42009-04-27 20:27:31 +0000745 }
746 if (!isPointer || !Ty->isVoidType()) {
747 if (RequireCompleteType(ThrowLoc, Ty,
David Majnemerba3e5ec2015-03-13 18:26:17 +0000748 isPointer ? diag::err_throw_incomplete_ptr
749 : diag::err_throw_incomplete,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +0000750 E->getSourceRange()))
David Majnemerba3e5ec2015-03-13 18:26:17 +0000751 return true;
Rafael Espindola70e040d2010-03-02 21:28:26 +0000752
David Majnemerd09a51c2015-03-03 01:50:05 +0000753 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
Douglas Gregorae298422012-05-04 17:09:59 +0000754 diag::err_throw_abstract_type, E))
David Majnemerba3e5ec2015-03-13 18:26:17 +0000755 return true;
Sebastian Redl4de47b42009-04-27 20:27:31 +0000756 }
757
Eli Friedman91a3d272010-06-03 20:39:03 +0000758 // If the exception has class type, we need additional handling.
David Majnemerba3e5ec2015-03-13 18:26:17 +0000759 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
760 if (!RD)
761 return false;
Eli Friedman91a3d272010-06-03 20:39:03 +0000762
Douglas Gregor88d292c2010-05-13 16:44:06 +0000763 // If we are throwing a polymorphic class type or pointer thereof,
764 // exception handling will make use of the vtable.
Eli Friedman91a3d272010-06-03 20:39:03 +0000765 MarkVTableUsed(ThrowLoc, RD);
766
Eli Friedman36ebbec2010-10-12 20:32:36 +0000767 // If a pointer is thrown, the referenced object will not be destroyed.
768 if (isPointer)
David Majnemerba3e5ec2015-03-13 18:26:17 +0000769 return false;
Eli Friedman36ebbec2010-10-12 20:32:36 +0000770
Richard Smitheec915d62012-02-18 04:13:32 +0000771 // If the class has a destructor, we must be able to call it.
David Majnemere7a818f2015-03-06 18:53:55 +0000772 if (!RD->hasIrrelevantDestructor()) {
773 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
774 MarkFunctionReferenced(E->getExprLoc(), Destructor);
775 CheckDestructorAccess(E->getExprLoc(), Destructor,
776 PDiag(diag::err_access_dtor_exception) << Ty);
777 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
David Majnemerba3e5ec2015-03-13 18:26:17 +0000778 return true;
David Majnemere7a818f2015-03-06 18:53:55 +0000779 }
780 }
Eli Friedman91a3d272010-06-03 20:39:03 +0000781
David Majnemerdfa6d202015-03-11 18:36:39 +0000782 // The MSVC ABI creates a list of all types which can catch the exception
783 // object. This list also references the appropriate copy constructor to call
784 // if the object is caught by value and has a non-trivial copy constructor.
David Majnemere7a818f2015-03-06 18:53:55 +0000785 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
David Majnemerdfa6d202015-03-11 18:36:39 +0000786 // We are only interested in the public, unambiguous bases contained within
787 // the exception object. Bases which are ambiguous or otherwise
788 // inaccessible are not catchable types.
David Majnemere7a818f2015-03-06 18:53:55 +0000789 llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;
790 getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);
David Majnemerdfa6d202015-03-11 18:36:39 +0000791
David Majnemere7a818f2015-03-06 18:53:55 +0000792 for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
David Majnemerdfa6d202015-03-11 18:36:39 +0000793 // Attempt to lookup the copy constructor. Various pieces of machinery
794 // will spring into action, like template instantiation, which means this
795 // cannot be a simple walk of the class's decls. Instead, we must perform
796 // lookup and overload resolution.
797 CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);
798 if (!CD)
799 continue;
800
801 // Mark the constructor referenced as it is used by this throw expression.
802 MarkFunctionReferenced(E->getExprLoc(), CD);
803
804 // Skip this copy constructor if it is trivial, we don't need to record it
805 // in the catchable type data.
806 if (CD->isTrivial())
807 continue;
808
809 // The copy constructor is non-trivial, create a mapping from this class
810 // type to this constructor.
811 // N.B. The selection of copy constructor is not sensitive to this
812 // particular throw-site. Lookup will be performed at the catch-site to
813 // ensure that the copy constructor is, in fact, accessible (via
814 // friendship or any other means).
815 Context.addCopyConstructorForExceptionObject(Subobject, CD);
816
817 // We don't keep the instantiated default argument expressions around so
818 // we must rebuild them here.
819 for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
820 // Skip any default arguments that we've already instantiated.
821 if (Context.getDefaultArgExprForConstructor(CD, I))
822 continue;
823
824 Expr *DefaultArg =
825 BuildCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)).get();
826 Context.addDefaultArgExprForConstructor(CD, I, DefaultArg);
David Majnemere7a818f2015-03-06 18:53:55 +0000827 }
828 }
829 }
Eli Friedman91a3d272010-06-03 20:39:03 +0000830
David Majnemerba3e5ec2015-03-13 18:26:17 +0000831 return false;
Chris Lattnerb7e656b2008-02-26 00:51:44 +0000832}
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000833
Eli Friedman73a04092012-01-07 04:59:52 +0000834QualType Sema::getCurrentThisType() {
835 DeclContext *DC = getFunctionLevelDeclContext();
Douglas Gregor3024f072012-04-16 07:05:22 +0000836 QualType ThisTy = CXXThisTypeOverride;
Richard Smith938f40b2011-06-11 17:19:42 +0000837 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
838 if (method && method->isInstance())
839 ThisTy = method->getThisType(Context);
Richard Smith938f40b2011-06-11 17:19:42 +0000840 }
Faisal Vali47d9ed42014-05-30 04:39:37 +0000841 if (ThisTy.isNull()) {
842 if (isGenericLambdaCallOperatorSpecialization(CurContext) &&
843 CurContext->getParent()->getParent()->isRecord()) {
844 // This is a generic lambda call operator that is being instantiated
845 // within a default initializer - so use the enclosing class as 'this'.
846 // There is no enclosing member function to retrieve the 'this' pointer
847 // from.
848 QualType ClassTy = Context.getTypeDeclType(
849 cast<CXXRecordDecl>(CurContext->getParent()->getParent()));
850 // There are no cv-qualifiers for 'this' within default initializers,
851 // per [expr.prim.general]p4.
852 return Context.getPointerType(ClassTy);
853 }
854 }
Richard Smith938f40b2011-06-11 17:19:42 +0000855 return ThisTy;
John McCallf3a88602011-02-03 08:15:49 +0000856}
857
Douglas Gregor3024f072012-04-16 07:05:22 +0000858Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S,
859 Decl *ContextDecl,
860 unsigned CXXThisTypeQuals,
861 bool Enabled)
862 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
863{
864 if (!Enabled || !ContextDecl)
865 return;
Craig Topperc3ec1492014-05-26 06:22:03 +0000866
867 CXXRecordDecl *Record = nullptr;
Douglas Gregor3024f072012-04-16 07:05:22 +0000868 if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
869 Record = Template->getTemplatedDecl();
870 else
871 Record = cast<CXXRecordDecl>(ContextDecl);
872
873 S.CXXThisTypeOverride
874 = S.Context.getPointerType(
875 S.Context.getRecordType(Record).withCVRQualifiers(CXXThisTypeQuals));
876
877 this->Enabled = true;
878}
879
880
881Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
882 if (Enabled) {
883 S.CXXThisTypeOverride = OldCXXThisTypeOverride;
884 }
885}
886
Ben Langmuire7d7c4c2013-04-29 13:32:41 +0000887static Expr *captureThis(ASTContext &Context, RecordDecl *RD,
888 QualType ThisTy, SourceLocation Loc) {
889 FieldDecl *Field
Craig Topperc3ec1492014-05-26 06:22:03 +0000890 = FieldDecl::Create(Context, RD, Loc, Loc, nullptr, ThisTy,
Ben Langmuire7d7c4c2013-04-29 13:32:41 +0000891 Context.getTrivialTypeSourceInfo(ThisTy, Loc),
Craig Topperc3ec1492014-05-26 06:22:03 +0000892 nullptr, false, ICIS_NoInit);
Ben Langmuire7d7c4c2013-04-29 13:32:41 +0000893 Field->setImplicit(true);
894 Field->setAccess(AS_private);
895 RD->addDecl(Field);
896 return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/true);
897}
898
Faisal Valia17d19f2013-11-07 05:17:06 +0000899bool Sema::CheckCXXThisCapture(SourceLocation Loc, bool Explicit,
900 bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt) {
Eli Friedman73a04092012-01-07 04:59:52 +0000901 // We don't need to capture this in an unevaluated context.
John McCallf413f5e2013-05-03 00:10:13 +0000902 if (isUnevaluatedContext() && !Explicit)
Faisal Valia17d19f2013-11-07 05:17:06 +0000903 return true;
Eli Friedman73a04092012-01-07 04:59:52 +0000904
Faisal Valia17d19f2013-11-07 05:17:06 +0000905 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt ?
906 *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
907 // Otherwise, check that we can capture 'this'.
Eli Friedman73a04092012-01-07 04:59:52 +0000908 unsigned NumClosures = 0;
Faisal Valia17d19f2013-11-07 05:17:06 +0000909 for (unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {
Eli Friedman20139d32012-01-11 02:36:31 +0000910 if (CapturingScopeInfo *CSI =
911 dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
912 if (CSI->CXXThisCaptureIndex != 0) {
913 // 'this' is already being captured; there isn't anything more to do.
Eli Friedman73a04092012-01-07 04:59:52 +0000914 break;
915 }
Faisal Valia17d19f2013-11-07 05:17:06 +0000916 LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
917 if (LSI && isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) {
918 // This context can't implicitly capture 'this'; fail out.
919 if (BuildAndDiagnose)
920 Diag(Loc, diag::err_this_capture) << Explicit;
921 return true;
922 }
Eli Friedman20139d32012-01-11 02:36:31 +0000923 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
Douglas Gregora1bffa22012-02-10 17:46:20 +0000924 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
Douglas Gregorcdd11d42012-02-01 17:04:21 +0000925 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +0000926 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
Douglas Gregorcdd11d42012-02-01 17:04:21 +0000927 Explicit) {
928 // This closure can capture 'this'; continue looking upwards.
Eli Friedman73a04092012-01-07 04:59:52 +0000929 NumClosures++;
Douglas Gregorcdd11d42012-02-01 17:04:21 +0000930 Explicit = false;
Eli Friedman73a04092012-01-07 04:59:52 +0000931 continue;
932 }
Eli Friedman20139d32012-01-11 02:36:31 +0000933 // This context can't implicitly capture 'this'; fail out.
Faisal Valia17d19f2013-11-07 05:17:06 +0000934 if (BuildAndDiagnose)
935 Diag(Loc, diag::err_this_capture) << Explicit;
936 return true;
Eli Friedman73a04092012-01-07 04:59:52 +0000937 }
Eli Friedman73a04092012-01-07 04:59:52 +0000938 break;
939 }
Faisal Valia17d19f2013-11-07 05:17:06 +0000940 if (!BuildAndDiagnose) return false;
Eli Friedman73a04092012-01-07 04:59:52 +0000941 // Mark that we're implicitly capturing 'this' in all the scopes we skipped.
942 // FIXME: We need to delay this marking in PotentiallyPotentiallyEvaluated
943 // contexts.
Faisal Valia17d19f2013-11-07 05:17:06 +0000944 for (unsigned idx = MaxFunctionScopesIndex; NumClosures;
945 --idx, --NumClosures) {
Eli Friedman20139d32012-01-11 02:36:31 +0000946 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
Craig Topperc3ec1492014-05-26 06:22:03 +0000947 Expr *ThisExpr = nullptr;
Douglas Gregorfdf598e2012-02-18 09:37:24 +0000948 QualType ThisTy = getCurrentThisType();
Ben Langmuire7d7c4c2013-04-29 13:32:41 +0000949 if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI))
Eli Friedmanc9751062012-02-11 02:51:16 +0000950 // For lambda expressions, build a field and an initializing expression.
Ben Langmuire7d7c4c2013-04-29 13:32:41 +0000951 ThisExpr = captureThis(Context, LSI->Lambda, ThisTy, Loc);
952 else if (CapturedRegionScopeInfo *RSI
953 = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
954 ThisExpr = captureThis(Context, RSI->TheRecordDecl, ThisTy, Loc);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +0000955
Eli Friedman20139d32012-01-11 02:36:31 +0000956 bool isNested = NumClosures > 1;
Douglas Gregorfdf598e2012-02-18 09:37:24 +0000957 CSI->addThisCapture(isNested, Loc, ThisTy, ThisExpr);
Eli Friedman73a04092012-01-07 04:59:52 +0000958 }
Faisal Valia17d19f2013-11-07 05:17:06 +0000959 return false;
Eli Friedman73a04092012-01-07 04:59:52 +0000960}
961
Richard Smith938f40b2011-06-11 17:19:42 +0000962ExprResult Sema::ActOnCXXThis(SourceLocation Loc) {
John McCallf3a88602011-02-03 08:15:49 +0000963 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
964 /// is a non-lvalue expression whose value is the address of the object for
965 /// which the function is called.
966
Douglas Gregor09deffa2011-10-18 16:47:30 +0000967 QualType ThisTy = getCurrentThisType();
Richard Smith938f40b2011-06-11 17:19:42 +0000968 if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
John McCallf3a88602011-02-03 08:15:49 +0000969
Eli Friedman73a04092012-01-07 04:59:52 +0000970 CheckCXXThisCapture(Loc);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000971 return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false);
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000972}
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000973
Douglas Gregor3024f072012-04-16 07:05:22 +0000974bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) {
975 // If we're outside the body of a member function, then we'll have a specified
976 // type for 'this'.
977 if (CXXThisTypeOverride.isNull())
978 return false;
979
980 // Determine whether we're looking into a class that's currently being
981 // defined.
982 CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl();
983 return Class && Class->isBeingDefined();
984}
985
John McCalldadc5752010-08-24 06:29:42 +0000986ExprResult
Douglas Gregor2b88c112010-09-08 00:15:04 +0000987Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000988 SourceLocation LParenLoc,
Sebastian Redl6d4256c2009-03-15 17:47:39 +0000989 MultiExprArg exprs,
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000990 SourceLocation RParenLoc) {
Douglas Gregor7df89f52010-02-05 19:11:37 +0000991 if (!TypeRep)
992 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000993
John McCall97513962010-01-15 18:39:57 +0000994 TypeSourceInfo *TInfo;
995 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
996 if (!TInfo)
997 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
Douglas Gregor2b88c112010-09-08 00:15:04 +0000998
999 return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
1000}
1001
1002/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1003/// Can be interpreted either as function-style casting ("int(x)")
1004/// or class type construction ("ClassType(x,y,z)")
1005/// or creation of a value-initialized type ("int()").
1006ExprResult
1007Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
1008 SourceLocation LParenLoc,
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001009 MultiExprArg Exprs,
Douglas Gregor2b88c112010-09-08 00:15:04 +00001010 SourceLocation RParenLoc) {
1011 QualType Ty = TInfo->getType();
Douglas Gregor2b88c112010-09-08 00:15:04 +00001012 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001013
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001014 if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001015 return CXXUnresolvedConstructExpr::Create(Context, TInfo, LParenLoc, Exprs,
1016 RParenLoc);
Douglas Gregor0950e412009-03-13 21:01:28 +00001017 }
1018
Sebastian Redld74dd492012-02-12 18:41:05 +00001019 bool ListInitialization = LParenLoc.isInvalid();
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001020 assert((!ListInitialization || (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0])))
Sebastian Redld74dd492012-02-12 18:41:05 +00001021 && "List initialization must have initializer list as expression.");
1022 SourceRange FullRange = SourceRange(TyBeginLoc,
1023 ListInitialization ? Exprs[0]->getSourceRange().getEnd() : RParenLoc);
1024
Douglas Gregordd04d332009-01-16 18:33:17 +00001025 // C++ [expr.type.conv]p1:
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001026 // If the expression list is a single expression, the type conversion
1027 // expression is equivalent (in definedness, and if defined in meaning) to the
1028 // corresponding cast expression.
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001029 if (Exprs.size() == 1 && !ListInitialization) {
John McCallb50451a2011-10-05 07:41:44 +00001030 Expr *Arg = Exprs[0];
John McCallb50451a2011-10-05 07:41:44 +00001031 return BuildCXXFunctionalCastExpr(TInfo, LParenLoc, Arg, RParenLoc);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001032 }
1033
David Majnemer7eddcff2015-09-14 07:05:00 +00001034 // C++14 [expr.type.conv]p2: The expression T(), where T is a
1035 // simple-type-specifier or typename-specifier for a non-array complete
1036 // object type or the (possibly cv-qualified) void type, creates a prvalue
1037 // of the specified type, whose value is that produced by value-initializing
1038 // an object of type T.
Eli Friedman576cbd02012-02-29 00:00:28 +00001039 QualType ElemTy = Ty;
1040 if (Ty->isArrayType()) {
1041 if (!ListInitialization)
1042 return ExprError(Diag(TyBeginLoc,
1043 diag::err_value_init_for_array_type) << FullRange);
1044 ElemTy = Context.getBaseElementType(Ty);
1045 }
1046
David Majnemer7eddcff2015-09-14 07:05:00 +00001047 if (!ListInitialization && Ty->isFunctionType())
1048 return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_function_type)
1049 << FullRange);
1050
Eli Friedman576cbd02012-02-29 00:00:28 +00001051 if (!Ty->isVoidType() &&
1052 RequireCompleteType(TyBeginLoc, ElemTy,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00001053 diag::err_invalid_incomplete_type_use, FullRange))
Eli Friedman576cbd02012-02-29 00:00:28 +00001054 return ExprError();
1055
1056 if (RequireNonAbstractType(TyBeginLoc, Ty,
1057 diag::err_allocation_of_abstract_type))
1058 return ExprError();
1059
Douglas Gregor8ec51732010-09-08 21:40:08 +00001060 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001061 InitializationKind Kind =
1062 Exprs.size() ? ListInitialization
1063 ? InitializationKind::CreateDirectList(TyBeginLoc)
1064 : InitializationKind::CreateDirect(TyBeginLoc, LParenLoc, RParenLoc)
1065 : InitializationKind::CreateValue(TyBeginLoc, LParenLoc, RParenLoc);
1066 InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
1067 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001068
Richard Smith90061902013-09-23 02:20:00 +00001069 if (Result.isInvalid() || !ListInitialization)
1070 return Result;
1071
1072 Expr *Inner = Result.get();
1073 if (CXXBindTemporaryExpr *BTE = dyn_cast_or_null<CXXBindTemporaryExpr>(Inner))
1074 Inner = BTE->getSubExpr();
Richard Smith1ae689c2015-01-28 22:06:01 +00001075 if (!isa<CXXTemporaryObjectExpr>(Inner)) {
1076 // If we created a CXXTemporaryObjectExpr, that node also represents the
1077 // functional cast. Otherwise, create an explicit cast to represent
1078 // the syntactic form of a functional-style cast that was used here.
1079 //
1080 // FIXME: Creating a CXXFunctionalCastExpr around a CXXConstructExpr
1081 // would give a more consistent AST representation than using a
1082 // CXXTemporaryObjectExpr. It's also weird that the functional cast
1083 // is sometimes handled by initialization and sometimes not.
Richard Smith90061902013-09-23 02:20:00 +00001084 QualType ResultType = Result.get()->getType();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001085 Result = CXXFunctionalCastExpr::Create(
Richard Smith90061902013-09-23 02:20:00 +00001086 Context, ResultType, Expr::getValueKindForType(TInfo->getType()), TInfo,
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001087 CK_NoOp, Result.get(), /*Path=*/nullptr, LParenLoc, RParenLoc);
Sebastian Redl2b80af42012-02-13 19:55:43 +00001088 }
1089
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001090 return Result;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +00001091}
Argyrios Kyrtzidis7620ee42008-09-10 02:17:11 +00001092
John McCall284c48f2011-01-27 09:37:56 +00001093/// doesUsualArrayDeleteWantSize - Answers whether the usual
1094/// operator delete[] for the given type has a size_t parameter.
1095static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
1096 QualType allocType) {
1097 const RecordType *record =
1098 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
1099 if (!record) return false;
1100
1101 // Try to find an operator delete[] in class scope.
1102
1103 DeclarationName deleteName =
1104 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
1105 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
1106 S.LookupQualifiedName(ops, record->getDecl());
1107
1108 // We're just doing this for information.
1109 ops.suppressDiagnostics();
1110
1111 // Very likely: there's no operator delete[].
1112 if (ops.empty()) return false;
1113
1114 // If it's ambiguous, it should be illegal to call operator delete[]
1115 // on this thing, so it doesn't matter if we allocate extra space or not.
1116 if (ops.isAmbiguous()) return false;
1117
1118 LookupResult::Filter filter = ops.makeFilter();
1119 while (filter.hasNext()) {
1120 NamedDecl *del = filter.next()->getUnderlyingDecl();
1121
1122 // C++0x [basic.stc.dynamic.deallocation]p2:
1123 // A template instance is never a usual deallocation function,
1124 // regardless of its signature.
1125 if (isa<FunctionTemplateDecl>(del)) {
1126 filter.erase();
1127 continue;
1128 }
1129
1130 // C++0x [basic.stc.dynamic.deallocation]p2:
1131 // If class T does not declare [an operator delete[] with one
1132 // parameter] but does declare a member deallocation function
1133 // named operator delete[] with exactly two parameters, the
1134 // second of which has type std::size_t, then this function
1135 // is a usual deallocation function.
1136 if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) {
1137 filter.erase();
1138 continue;
1139 }
1140 }
1141 filter.done();
1142
1143 if (!ops.isSingleResult()) return false;
1144
1145 const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl());
1146 return (del->getNumParams() == 2);
1147}
Argyrios Kyrtzidis7620ee42008-09-10 02:17:11 +00001148
Sebastian Redld74dd492012-02-12 18:41:05 +00001149/// \brief Parsed a C++ 'new' expression (C++ 5.3.4).
James Dennettf14a6e52012-06-15 22:23:43 +00001150///
Sebastian Redld74dd492012-02-12 18:41:05 +00001151/// E.g.:
Sebastian Redlbd150f42008-11-21 19:14:01 +00001152/// @code new (memory) int[size][4] @endcode
1153/// or
1154/// @code ::new Foo(23, "hello") @endcode
Sebastian Redld74dd492012-02-12 18:41:05 +00001155///
1156/// \param StartLoc The first location of the expression.
1157/// \param UseGlobal True if 'new' was prefixed with '::'.
1158/// \param PlacementLParen Opening paren of the placement arguments.
1159/// \param PlacementArgs Placement new arguments.
1160/// \param PlacementRParen Closing paren of the placement arguments.
1161/// \param TypeIdParens If the type is in parens, the source range.
1162/// \param D The type to be allocated, as well as array dimensions.
James Dennettf14a6e52012-06-15 22:23:43 +00001163/// \param Initializer The initializing expression or initializer-list, or null
1164/// if there is none.
John McCalldadc5752010-08-24 06:29:42 +00001165ExprResult
Sebastian Redlbd150f42008-11-21 19:14:01 +00001166Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001167 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001168 SourceLocation PlacementRParen, SourceRange TypeIdParens,
Sebastian Redl6047f072012-02-16 12:22:20 +00001169 Declarator &D, Expr *Initializer) {
Richard Smith74aeef52013-04-26 16:15:35 +00001170 bool TypeContainsAuto = D.getDeclSpec().containsPlaceholderType();
Richard Smith30482bc2011-02-20 03:19:35 +00001171
Craig Topperc3ec1492014-05-26 06:22:03 +00001172 Expr *ArraySize = nullptr;
Sebastian Redl351bb782008-12-02 14:43:59 +00001173 // If the specified type is an array, unwrap it and save the expression.
1174 if (D.getNumTypeObjects() > 0 &&
1175 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
James Dennettf14a6e52012-06-15 22:23:43 +00001176 DeclaratorChunk &Chunk = D.getTypeObject(0);
Richard Smith30482bc2011-02-20 03:19:35 +00001177 if (TypeContainsAuto)
1178 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
1179 << D.getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00001180 if (Chunk.Arr.hasStatic)
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001181 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
1182 << D.getSourceRange());
Sebastian Redl351bb782008-12-02 14:43:59 +00001183 if (!Chunk.Arr.NumElts)
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001184 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
1185 << D.getSourceRange());
Sebastian Redld7b3d7d2009-10-25 21:45:37 +00001186
Sebastian Redl351bb782008-12-02 14:43:59 +00001187 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
Sebastian Redld7b3d7d2009-10-25 21:45:37 +00001188 D.DropFirstTypeObject();
Sebastian Redl351bb782008-12-02 14:43:59 +00001189 }
1190
Douglas Gregor73341c42009-09-11 00:18:58 +00001191 // Every dimension shall be of constant size.
Sebastian Redld7b3d7d2009-10-25 21:45:37 +00001192 if (ArraySize) {
1193 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
Douglas Gregor73341c42009-09-11 00:18:58 +00001194 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
1195 break;
1196
1197 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
1198 if (Expr *NumElts = (Expr *)Array.NumElts) {
Richard Smithf4c51d92012-02-04 09:53:13 +00001199 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001200 if (getLangOpts().CPlusPlus14) {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001201 // C++1y [expr.new]p6: Every constant-expression in a noptr-new-declarator
1202 // shall be a converted constant expression (5.19) of type std::size_t
1203 // and shall evaluate to a strictly positive value.
1204 unsigned IntWidth = Context.getTargetInfo().getIntWidth();
1205 assert(IntWidth && "Builtin type of size 0?");
1206 llvm::APSInt Value(IntWidth);
1207 Array.NumElts
1208 = CheckConvertedConstantExpression(NumElts, Context.getSizeType(), Value,
1209 CCEK_NewExpr)
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001210 .get();
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001211 } else {
1212 Array.NumElts
Craig Topperc3ec1492014-05-26 06:22:03 +00001213 = VerifyIntegerConstantExpression(NumElts, nullptr,
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001214 diag::err_new_array_nonconst)
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001215 .get();
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001216 }
Richard Smithf4c51d92012-02-04 09:53:13 +00001217 if (!Array.NumElts)
1218 return ExprError();
Douglas Gregor73341c42009-09-11 00:18:58 +00001219 }
1220 }
1221 }
1222 }
Sebastian Redld7b3d7d2009-10-25 21:45:37 +00001223
Craig Topperc3ec1492014-05-26 06:22:03 +00001224 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/nullptr);
John McCall8cb7bdf2010-06-04 23:28:52 +00001225 QualType AllocType = TInfo->getType();
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00001226 if (D.isInvalidType())
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001227 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001228
Sebastian Redl6047f072012-02-16 12:22:20 +00001229 SourceRange DirectInitRange;
1230 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1231 DirectInitRange = List->getSourceRange();
1232
David Blaikie7b97aef2012-11-07 00:12:38 +00001233 return BuildCXXNew(SourceRange(StartLoc, D.getLocEnd()), UseGlobal,
Douglas Gregord0fefba2009-05-21 00:00:09 +00001234 PlacementLParen,
Benjamin Kramer62b95d82012-08-23 21:35:17 +00001235 PlacementArgs,
Douglas Gregord0fefba2009-05-21 00:00:09 +00001236 PlacementRParen,
Douglas Gregorf2753b32010-07-13 15:54:32 +00001237 TypeIdParens,
Mike Stump11289f42009-09-09 15:08:12 +00001238 AllocType,
Douglas Gregor0744ef62010-09-07 21:49:58 +00001239 TInfo,
John McCallb268a282010-08-23 23:25:46 +00001240 ArraySize,
Sebastian Redl6047f072012-02-16 12:22:20 +00001241 DirectInitRange,
1242 Initializer,
Richard Smith30482bc2011-02-20 03:19:35 +00001243 TypeContainsAuto);
Douglas Gregord0fefba2009-05-21 00:00:09 +00001244}
1245
Sebastian Redlb8fc4772012-02-16 12:59:47 +00001246static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
1247 Expr *Init) {
Sebastian Redl6047f072012-02-16 12:22:20 +00001248 if (!Init)
1249 return true;
Sebastian Redleb54f082012-02-17 08:42:32 +00001250 if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
1251 return PLE->getNumExprs() == 0;
Sebastian Redl6047f072012-02-16 12:22:20 +00001252 if (isa<ImplicitValueInitExpr>(Init))
1253 return true;
1254 else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
1255 return !CCE->isListInitialization() &&
1256 CCE->getConstructor()->isDefaultConstructor();
Sebastian Redlb8fc4772012-02-16 12:59:47 +00001257 else if (Style == CXXNewExpr::ListInit) {
1258 assert(isa<InitListExpr>(Init) &&
1259 "Shouldn't create list CXXConstructExprs for arrays.");
1260 return true;
1261 }
Sebastian Redl6047f072012-02-16 12:22:20 +00001262 return false;
1263}
1264
John McCalldadc5752010-08-24 06:29:42 +00001265ExprResult
David Blaikie7b97aef2012-11-07 00:12:38 +00001266Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
Douglas Gregord0fefba2009-05-21 00:00:09 +00001267 SourceLocation PlacementLParen,
1268 MultiExprArg PlacementArgs,
1269 SourceLocation PlacementRParen,
Douglas Gregorf2753b32010-07-13 15:54:32 +00001270 SourceRange TypeIdParens,
Douglas Gregord0fefba2009-05-21 00:00:09 +00001271 QualType AllocType,
Douglas Gregor0744ef62010-09-07 21:49:58 +00001272 TypeSourceInfo *AllocTypeInfo,
John McCallb268a282010-08-23 23:25:46 +00001273 Expr *ArraySize,
Sebastian Redl6047f072012-02-16 12:22:20 +00001274 SourceRange DirectInitRange,
1275 Expr *Initializer,
Richard Smith30482bc2011-02-20 03:19:35 +00001276 bool TypeMayContainAuto) {
Douglas Gregor0744ef62010-09-07 21:49:58 +00001277 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
David Blaikie7b97aef2012-11-07 00:12:38 +00001278 SourceLocation StartLoc = Range.getBegin();
Sebastian Redl351bb782008-12-02 14:43:59 +00001279
Sebastian Redl6047f072012-02-16 12:22:20 +00001280 CXXNewExpr::InitializationStyle initStyle;
1281 if (DirectInitRange.isValid()) {
1282 assert(Initializer && "Have parens but no initializer.");
1283 initStyle = CXXNewExpr::CallInit;
1284 } else if (Initializer && isa<InitListExpr>(Initializer))
1285 initStyle = CXXNewExpr::ListInit;
1286 else {
1287 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1288 isa<CXXConstructExpr>(Initializer)) &&
1289 "Initializer expression that cannot have been implicitly created.");
1290 initStyle = CXXNewExpr::NoInit;
1291 }
1292
1293 Expr **Inits = &Initializer;
1294 unsigned NumInits = Initializer ? 1 : 0;
Richard Smithdd2ca572012-11-26 08:32:48 +00001295 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1296 assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
1297 Inits = List->getExprs();
1298 NumInits = List->getNumExprs();
Sebastian Redl6047f072012-02-16 12:22:20 +00001299 }
1300
Richard Smith66204ec2014-03-12 17:42:45 +00001301 // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
Richard Smith27d807c2013-04-30 13:56:41 +00001302 if (TypeMayContainAuto && AllocType->isUndeducedType()) {
Sebastian Redl6047f072012-02-16 12:22:20 +00001303 if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
Richard Smith30482bc2011-02-20 03:19:35 +00001304 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1305 << AllocType << TypeRange);
Richard Smith66204ec2014-03-12 17:42:45 +00001306 if (initStyle == CXXNewExpr::ListInit ||
1307 (NumInits == 1 && isa<InitListExpr>(Inits[0])))
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001308 return ExprError(Diag(Inits[0]->getLocStart(),
Richard Smith66204ec2014-03-12 17:42:45 +00001309 diag::err_auto_new_list_init)
Sebastian Redl6047f072012-02-16 12:22:20 +00001310 << AllocType << TypeRange);
1311 if (NumInits > 1) {
1312 Expr *FirstBad = Inits[1];
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001313 return ExprError(Diag(FirstBad->getLocStart(),
Richard Smith30482bc2011-02-20 03:19:35 +00001314 diag::err_auto_new_ctor_multiple_expressions)
1315 << AllocType << TypeRange);
1316 }
Sebastian Redl6047f072012-02-16 12:22:20 +00001317 Expr *Deduce = Inits[0];
Richard Smith061f1e22013-04-30 21:23:01 +00001318 QualType DeducedType;
Richard Smith74801c82012-07-08 04:13:07 +00001319 if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
Richard Smith30482bc2011-02-20 03:19:35 +00001320 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
Sebastian Redld74dd492012-02-12 18:41:05 +00001321 << AllocType << Deduce->getType()
1322 << TypeRange << Deduce->getSourceRange());
Richard Smith061f1e22013-04-30 21:23:01 +00001323 if (DeducedType.isNull())
Richard Smith9647d3c2011-03-17 16:11:59 +00001324 return ExprError();
Richard Smith061f1e22013-04-30 21:23:01 +00001325 AllocType = DeducedType;
Richard Smith30482bc2011-02-20 03:19:35 +00001326 }
Sebastian Redld74dd492012-02-12 18:41:05 +00001327
Douglas Gregorcda95f42010-05-16 16:01:03 +00001328 // Per C++0x [expr.new]p5, the type being constructed may be a
1329 // typedef of an array type.
John McCallb268a282010-08-23 23:25:46 +00001330 if (!ArraySize) {
Douglas Gregorcda95f42010-05-16 16:01:03 +00001331 if (const ConstantArrayType *Array
1332 = Context.getAsConstantArrayType(AllocType)) {
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00001333 ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
1334 Context.getSizeType(),
1335 TypeRange.getEnd());
Douglas Gregorcda95f42010-05-16 16:01:03 +00001336 AllocType = Array->getElementType();
1337 }
1338 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00001339
Douglas Gregor3999e152010-10-06 16:00:31 +00001340 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
1341 return ExprError();
1342
Craig Topperc3ec1492014-05-26 06:22:03 +00001343 if (initStyle == CXXNewExpr::ListInit &&
1344 isStdInitializerList(AllocType, nullptr)) {
Sebastian Redld74dd492012-02-12 18:41:05 +00001345 Diag(AllocTypeInfo->getTypeLoc().getBeginLoc(),
1346 diag::warn_dangling_std_initializer_list)
Sebastian Redl73cfbeb2012-02-19 16:31:05 +00001347 << /*at end of FE*/0 << Inits[0]->getSourceRange();
Sebastian Redld74dd492012-02-12 18:41:05 +00001348 }
1349
John McCall31168b02011-06-15 23:02:42 +00001350 // In ARC, infer 'retaining' for the allocated
David Blaikiebbafb8a2012-03-11 07:00:24 +00001351 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00001352 AllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1353 AllocType->isObjCLifetimeType()) {
1354 AllocType = Context.getLifetimeQualifiedType(AllocType,
1355 AllocType->getObjCARCImplicitLifetime());
1356 }
Sebastian Redl351bb782008-12-02 14:43:59 +00001357
John McCall31168b02011-06-15 23:02:42 +00001358 QualType ResultType = Context.getPointerType(AllocType);
1359
John McCall5e77d762013-04-16 07:28:30 +00001360 if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) {
1361 ExprResult result = CheckPlaceholderExpr(ArraySize);
1362 if (result.isInvalid()) return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001363 ArraySize = result.get();
John McCall5e77d762013-04-16 07:28:30 +00001364 }
Richard Smith8dd34252012-02-04 07:07:42 +00001365 // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have
1366 // integral or enumeration type with a non-negative value."
1367 // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped
1368 // enumeration type, or a class type for which a single non-explicit
1369 // conversion function to integral or unscoped enumeration type exists.
Richard Smithccc11812013-05-21 19:05:48 +00001370 // C++1y [expr.new]p6: The expression [...] is implicitly converted to
Larisse Voufobf4aa572013-06-18 03:08:53 +00001371 // std::size_t.
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001372 if (ArraySize && !ArraySize->isTypeDependent()) {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001373 ExprResult ConvertedSize;
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001374 if (getLangOpts().CPlusPlus14) {
Alp Toker965f8822013-11-27 05:22:15 +00001375 assert(Context.getTargetInfo().getIntWidth() && "Builtin type of size 0?");
1376
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001377 ConvertedSize = PerformImplicitConversion(ArraySize, Context.getSizeType(),
1378 AA_Converting);
Richard Smithccc11812013-05-21 19:05:48 +00001379
Larisse Voufobf4aa572013-06-18 03:08:53 +00001380 if (!ConvertedSize.isInvalid() &&
1381 ArraySize->getType()->getAs<RecordType>())
Larisse Voufo9f380c52013-06-18 01:27:47 +00001382 // Diagnose the compatibility of this conversion.
1383 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1384 << ArraySize->getType() << 0 << "'size_t'";
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001385 } else {
1386 class SizeConvertDiagnoser : public ICEConvertDiagnoser {
1387 protected:
1388 Expr *ArraySize;
1389
1390 public:
1391 SizeConvertDiagnoser(Expr *ArraySize)
1392 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, false, false),
1393 ArraySize(ArraySize) {}
Craig Toppere14c0f82014-03-12 04:55:44 +00001394
1395 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1396 QualType T) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001397 return S.Diag(Loc, diag::err_array_size_not_integral)
1398 << S.getLangOpts().CPlusPlus11 << T;
1399 }
Craig Toppere14c0f82014-03-12 04:55:44 +00001400
1401 SemaDiagnosticBuilder diagnoseIncomplete(
1402 Sema &S, SourceLocation Loc, QualType T) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001403 return S.Diag(Loc, diag::err_array_size_incomplete_type)
1404 << T << ArraySize->getSourceRange();
1405 }
Craig Toppere14c0f82014-03-12 04:55:44 +00001406
1407 SemaDiagnosticBuilder diagnoseExplicitConv(
1408 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001409 return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1410 }
Craig Toppere14c0f82014-03-12 04:55:44 +00001411
1412 SemaDiagnosticBuilder noteExplicitConv(
1413 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001414 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1415 << ConvTy->isEnumeralType() << ConvTy;
1416 }
Craig Toppere14c0f82014-03-12 04:55:44 +00001417
1418 SemaDiagnosticBuilder diagnoseAmbiguous(
1419 Sema &S, SourceLocation Loc, QualType T) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001420 return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1421 }
Craig Toppere14c0f82014-03-12 04:55:44 +00001422
1423 SemaDiagnosticBuilder noteAmbiguous(
1424 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001425 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1426 << ConvTy->isEnumeralType() << ConvTy;
1427 }
Richard Smithccc11812013-05-21 19:05:48 +00001428
Alexander Kornienko34eb2072015-04-11 02:00:23 +00001429 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1430 QualType T,
1431 QualType ConvTy) override {
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001432 return S.Diag(Loc,
1433 S.getLangOpts().CPlusPlus11
1434 ? diag::warn_cxx98_compat_array_size_conversion
1435 : diag::ext_array_size_conversion)
1436 << T << ConvTy->isEnumeralType() << ConvTy;
1437 }
1438 } SizeDiagnoser(ArraySize);
Richard Smithccc11812013-05-21 19:05:48 +00001439
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001440 ConvertedSize = PerformContextualImplicitConversion(StartLoc, ArraySize,
1441 SizeDiagnoser);
1442 }
Douglas Gregor4799d032010-06-30 00:20:43 +00001443 if (ConvertedSize.isInvalid())
1444 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001445
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001446 ArraySize = ConvertedSize.get();
John McCall9b80c212012-01-11 00:14:46 +00001447 QualType SizeType = ArraySize->getType();
Larisse Voufo0f1394c2013-06-15 20:17:46 +00001448
Douglas Gregor0bf31402010-10-08 23:50:27 +00001449 if (!SizeType->isIntegralOrUnscopedEnumerationType())
Douglas Gregor4799d032010-06-30 00:20:43 +00001450 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001451
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001452 // C++98 [expr.new]p7:
1453 // The expression in a direct-new-declarator shall have integral type
1454 // with a non-negative value.
1455 //
1456 // Let's see if this is a constant < 0. If so, we reject it out of
1457 // hand. Otherwise, if it's not a constant, we must have an unparenthesized
1458 // array type.
1459 //
1460 // Note: such a construct has well-defined semantics in C++11: it throws
1461 // std::bad_array_new_length.
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001462 if (!ArraySize->isValueDependent()) {
1463 llvm::APSInt Value;
Richard Smithf4c51d92012-02-04 09:53:13 +00001464 // We've already performed any required implicit conversion to integer or
1465 // unscoped enumeration type.
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001466 if (ArraySize->isIntegerConstantExpr(Value, Context)) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001467 if (Value < llvm::APSInt(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001468 llvm::APInt::getNullValue(Value.getBitWidth()),
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001469 Value.isUnsigned())) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001470 if (getLangOpts().CPlusPlus11)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001471 Diag(ArraySize->getLocStart(),
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001472 diag::warn_typecheck_negative_array_new_size)
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00001473 << ArraySize->getSourceRange();
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001474 else
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001475 return ExprError(Diag(ArraySize->getLocStart(),
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001476 diag::err_typecheck_negative_array_size)
1477 << ArraySize->getSourceRange());
1478 } else if (!AllocType->isDependentType()) {
1479 unsigned ActiveSizeBits =
1480 ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
1481 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001482 if (getLangOpts().CPlusPlus11)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001483 Diag(ArraySize->getLocStart(),
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001484 diag::warn_array_new_too_large)
1485 << Value.toString(10)
1486 << ArraySize->getSourceRange();
1487 else
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001488 return ExprError(Diag(ArraySize->getLocStart(),
Richard Smithbcc9bcb2012-02-04 05:35:53 +00001489 diag::err_array_too_large)
1490 << Value.toString(10)
1491 << ArraySize->getSourceRange());
Douglas Gregorcaa1bf42010-08-18 00:39:00 +00001492 }
1493 }
Douglas Gregorf2753b32010-07-13 15:54:32 +00001494 } else if (TypeIdParens.isValid()) {
1495 // Can't have dynamic array size when the type-id is in parentheses.
1496 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
1497 << ArraySize->getSourceRange()
1498 << FixItHint::CreateRemoval(TypeIdParens.getBegin())
1499 << FixItHint::CreateRemoval(TypeIdParens.getEnd());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001500
Douglas Gregorf2753b32010-07-13 15:54:32 +00001501 TypeIdParens = SourceRange();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001502 }
Sebastian Redl351bb782008-12-02 14:43:59 +00001503 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001504
John McCall036f2f62011-05-15 07:14:44 +00001505 // Note that we do *not* convert the argument in any way. It can
1506 // be signed, larger than size_t, whatever.
Sebastian Redl351bb782008-12-02 14:43:59 +00001507 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00001508
Craig Topperc3ec1492014-05-26 06:22:03 +00001509 FunctionDecl *OperatorNew = nullptr;
1510 FunctionDecl *OperatorDelete = nullptr;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001511
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001512 if (!AllocType->isDependentType() &&
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001513 !Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00001514 FindAllocationFunctions(StartLoc,
Sebastian Redl1df2bbe2009-02-09 18:24:27 +00001515 SourceRange(PlacementLParen, PlacementRParen),
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001516 UseGlobal, AllocType, ArraySize, PlacementArgs,
1517 OperatorNew, OperatorDelete))
Sebastian Redl6d4256c2009-03-15 17:47:39 +00001518 return ExprError();
John McCall284c48f2011-01-27 09:37:56 +00001519
1520 // If this is an array allocation, compute whether the usual array
1521 // deallocation function for the type has a size_t parameter.
1522 bool UsualArrayDeleteWantsSize = false;
1523 if (ArraySize && !AllocType->isDependentType())
1524 UsualArrayDeleteWantsSize
1525 = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
1526
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001527 SmallVector<Expr *, 8> AllPlaceArgs;
Fariborz Jahanian1eab66c2009-11-19 18:39:40 +00001528 if (OperatorNew) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001529 const FunctionProtoType *Proto =
Richard Smithd6f9e732014-05-13 19:56:21 +00001530 OperatorNew->getType()->getAs<FunctionProtoType>();
1531 VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction
1532 : VariadicDoesNotApply;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001533
Richard Smithd6f9e732014-05-13 19:56:21 +00001534 // We've already converted the placement args, just fill in any default
1535 // arguments. Skip the first parameter because we don't have a corresponding
1536 // argument.
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001537 if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto, 1,
1538 PlacementArgs, AllPlaceArgs, CallType))
Fariborz Jahanian835026e2009-11-24 18:29:37 +00001539 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001540
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001541 if (!AllPlaceArgs.empty())
1542 PlacementArgs = AllPlaceArgs;
Eli Friedmanff4b4072012-02-18 04:48:30 +00001543
Richard Smithd6f9e732014-05-13 19:56:21 +00001544 // FIXME: This is wrong: PlacementArgs misses out the first (size) argument.
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001545 DiagnoseSentinelCalls(OperatorNew, PlacementLParen, PlacementArgs);
Eli Friedmanff4b4072012-02-18 04:48:30 +00001546
1547 // FIXME: Missing call to CheckFunctionCall or equivalent
Fariborz Jahanian1eab66c2009-11-19 18:39:40 +00001548 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001549
Nick Lewycky411fc652012-01-24 21:15:41 +00001550 // Warn if the type is over-aligned and is being allocated by global operator
1551 // new.
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001552 if (PlacementArgs.empty() && OperatorNew &&
Nick Lewycky411fc652012-01-24 21:15:41 +00001553 (OperatorNew->isImplicit() ||
1554 getSourceManager().isInSystemHeader(OperatorNew->getLocStart()))) {
1555 if (unsigned Align = Context.getPreferredTypeAlign(AllocType.getTypePtr())){
1556 unsigned SuitableAlign = Context.getTargetInfo().getSuitableAlign();
1557 if (Align > SuitableAlign)
1558 Diag(StartLoc, diag::warn_overaligned_type)
1559 << AllocType
1560 << unsigned(Align / Context.getCharWidth())
1561 << unsigned(SuitableAlign / Context.getCharWidth());
1562 }
1563 }
1564
Sebastian Redlb8fc4772012-02-16 12:59:47 +00001565 QualType InitType = AllocType;
Sebastian Redl6047f072012-02-16 12:22:20 +00001566 // Array 'new' can't have any initializers except empty parentheses.
Sebastian Redlb8fc4772012-02-16 12:59:47 +00001567 // Initializer lists are also allowed, in C++11. Rely on the parser for the
1568 // dialect distinction.
1569 if (ResultType->isArrayType() || ArraySize) {
1570 if (!isLegalArrayNewInitializer(initStyle, Initializer)) {
1571 SourceRange InitRange(Inits[0]->getLocStart(),
1572 Inits[NumInits - 1]->getLocEnd());
1573 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
1574 return ExprError();
1575 }
1576 if (InitListExpr *ILE = dyn_cast_or_null<InitListExpr>(Initializer)) {
1577 // We do the initialization typechecking against the array type
1578 // corresponding to the number of initializers + 1 (to also check
1579 // default-initialization).
1580 unsigned NumElements = ILE->getNumInits() + 1;
1581 InitType = Context.getConstantArrayType(AllocType,
1582 llvm::APInt(Context.getTypeSize(Context.getSizeType()), NumElements),
1583 ArrayType::Normal, 0);
1584 }
Anders Carlssonc6bb0e12010-05-03 15:45:23 +00001585 }
1586
Richard Smithdd2ca572012-11-26 08:32:48 +00001587 // If we can perform the initialization, and we've not already done so,
1588 // do it now.
Douglas Gregor85dabae2009-12-16 01:38:02 +00001589 if (!AllocType->isDependentType() &&
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00001590 !Expr::hasAnyTypeDependentArguments(
Richard Smithc6abd962014-07-25 01:12:44 +00001591 llvm::makeArrayRef(Inits, NumInits))) {
Sebastian Redld74dd492012-02-12 18:41:05 +00001592 // C++11 [expr.new]p15:
Douglas Gregor85dabae2009-12-16 01:38:02 +00001593 // A new-expression that creates an object of type T initializes that
1594 // object as follows:
1595 InitializationKind Kind
1596 // - If the new-initializer is omitted, the object is default-
1597 // initialized (8.5); if no initialization is performed,
1598 // the object has indeterminate value
Sebastian Redl6047f072012-02-16 12:22:20 +00001599 = initStyle == CXXNewExpr::NoInit
1600 ? InitializationKind::CreateDefault(TypeRange.getBegin())
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001601 // - Otherwise, the new-initializer is interpreted according to the
Douglas Gregor85dabae2009-12-16 01:38:02 +00001602 // initialization rules of 8.5 for direct-initialization.
Sebastian Redl6047f072012-02-16 12:22:20 +00001603 : initStyle == CXXNewExpr::ListInit
1604 ? InitializationKind::CreateDirectList(TypeRange.getBegin())
1605 : InitializationKind::CreateDirect(TypeRange.getBegin(),
1606 DirectInitRange.getBegin(),
1607 DirectInitRange.getEnd());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001608
Douglas Gregor85dabae2009-12-16 01:38:02 +00001609 InitializedEntity Entity
Sebastian Redlb8fc4772012-02-16 12:59:47 +00001610 = InitializedEntity::InitializeNew(StartLoc, InitType);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00001611 InitializationSequence InitSeq(*this, Entity, Kind, MultiExprArg(Inits, NumInits));
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001612 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
Sebastian Redl6047f072012-02-16 12:22:20 +00001613 MultiExprArg(Inits, NumInits));
Douglas Gregor85dabae2009-12-16 01:38:02 +00001614 if (FullInit.isInvalid())
1615 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001616
Sebastian Redl6047f072012-02-16 12:22:20 +00001617 // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
1618 // we don't want the initialized object to be destructed.
1619 if (CXXBindTemporaryExpr *Binder =
1620 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001621 FullInit = Binder->getSubExpr();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001622
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001623 Initializer = FullInit.get();
Sebastian Redlbd150f42008-11-21 19:14:01 +00001624 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001625
Douglas Gregor6642ca22010-02-26 05:06:18 +00001626 // Mark the new and delete operators as referenced.
Nick Lewyckya096b142013-02-12 08:08:54 +00001627 if (OperatorNew) {
Richard Smith22262ab2013-05-04 06:44:46 +00001628 if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
1629 return ExprError();
Eli Friedmanfa0df832012-02-02 03:46:19 +00001630 MarkFunctionReferenced(StartLoc, OperatorNew);
Nick Lewyckya096b142013-02-12 08:08:54 +00001631 }
1632 if (OperatorDelete) {
Richard Smith22262ab2013-05-04 06:44:46 +00001633 if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
1634 return ExprError();
Eli Friedmanfa0df832012-02-02 03:46:19 +00001635 MarkFunctionReferenced(StartLoc, OperatorDelete);
Nick Lewyckya096b142013-02-12 08:08:54 +00001636 }
Douglas Gregor6642ca22010-02-26 05:06:18 +00001637
John McCall928a2572011-07-13 20:12:57 +00001638 // C++0x [expr.new]p17:
1639 // If the new expression creates an array of objects of class type,
1640 // access and ambiguity control are done for the destructor.
David Blaikie631a4862012-03-10 23:40:02 +00001641 QualType BaseAllocType = Context.getBaseElementType(AllocType);
1642 if (ArraySize && !BaseAllocType->isDependentType()) {
1643 if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
1644 if (CXXDestructorDecl *dtor = LookupDestructor(
1645 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
1646 MarkFunctionReferenced(StartLoc, dtor);
1647 CheckDestructorAccess(StartLoc, dtor,
1648 PDiag(diag::err_access_dtor)
1649 << BaseAllocType);
Richard Smith22262ab2013-05-04 06:44:46 +00001650 if (DiagnoseUseOfDecl(dtor, StartLoc))
1651 return ExprError();
David Blaikie631a4862012-03-10 23:40:02 +00001652 }
John McCall928a2572011-07-13 20:12:57 +00001653 }
1654 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001655
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001656 return new (Context)
1657 CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete,
1658 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
1659 ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
1660 Range, DirectInitRange);
Sebastian Redlbd150f42008-11-21 19:14:01 +00001661}
1662
Sebastian Redl6047f072012-02-16 12:22:20 +00001663/// \brief Checks that a type is suitable as the allocated type
Sebastian Redlbd150f42008-11-21 19:14:01 +00001664/// in a new-expression.
Douglas Gregord0fefba2009-05-21 00:00:09 +00001665bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
Mike Stump11289f42009-09-09 15:08:12 +00001666 SourceRange R) {
Sebastian Redlbd150f42008-11-21 19:14:01 +00001667 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
1668 // abstract class type or array thereof.
Douglas Gregorac1fb652009-03-24 19:52:54 +00001669 if (AllocType->isFunctionType())
Douglas Gregord0fefba2009-05-21 00:00:09 +00001670 return Diag(Loc, diag::err_bad_new_type)
1671 << AllocType << 0 << R;
Douglas Gregorac1fb652009-03-24 19:52:54 +00001672 else if (AllocType->isReferenceType())
Douglas Gregord0fefba2009-05-21 00:00:09 +00001673 return Diag(Loc, diag::err_bad_new_type)
1674 << AllocType << 1 << R;
Douglas Gregorac1fb652009-03-24 19:52:54 +00001675 else if (!AllocType->isDependentType() &&
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00001676 RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
Sebastian Redlbd150f42008-11-21 19:14:01 +00001677 return true;
Douglas Gregord0fefba2009-05-21 00:00:09 +00001678 else if (RequireNonAbstractType(Loc, AllocType,
Douglas Gregorac1fb652009-03-24 19:52:54 +00001679 diag::err_allocation_of_abstract_type))
1680 return true;
Douglas Gregor3999e152010-10-06 16:00:31 +00001681 else if (AllocType->isVariablyModifiedType())
1682 return Diag(Loc, diag::err_variably_modified_new_type)
1683 << AllocType;
Douglas Gregor39d1a092011-04-15 19:46:20 +00001684 else if (unsigned AddressSpace = AllocType.getAddressSpace())
1685 return Diag(Loc, diag::err_address_space_qualified_new)
1686 << AllocType.getUnqualifiedType() << AddressSpace;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001687 else if (getLangOpts().ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +00001688 if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {
1689 QualType BaseAllocType = Context.getBaseElementType(AT);
1690 if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1691 BaseAllocType->isObjCLifetimeType())
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +00001692 return Diag(Loc, diag::err_arc_new_array_without_ownership)
John McCall31168b02011-06-15 23:02:42 +00001693 << BaseAllocType;
1694 }
1695 }
Douglas Gregor39d1a092011-04-15 19:46:20 +00001696
Sebastian Redlbd150f42008-11-21 19:14:01 +00001697 return false;
1698}
1699
Douglas Gregor6642ca22010-02-26 05:06:18 +00001700/// \brief Determine whether the given function is a non-placement
1701/// deallocation function.
Richard Smith1cdec012013-09-29 04:40:38 +00001702static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
Douglas Gregor6642ca22010-02-26 05:06:18 +00001703 if (FD->isInvalidDecl())
1704 return false;
1705
1706 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1707 return Method->isUsualDeallocationFunction();
1708
Richard Smith1cdec012013-09-29 04:40:38 +00001709 if (FD->getOverloadedOperator() != OO_Delete &&
1710 FD->getOverloadedOperator() != OO_Array_Delete)
1711 return false;
1712
1713 if (FD->getNumParams() == 1)
1714 return true;
1715
1716 return S.getLangOpts().SizedDeallocation && FD->getNumParams() == 2 &&
1717 S.Context.hasSameUnqualifiedType(FD->getParamDecl(1)->getType(),
1718 S.Context.getSizeType());
Douglas Gregor6642ca22010-02-26 05:06:18 +00001719}
1720
Sebastian Redlfaf68082008-12-03 20:26:15 +00001721/// FindAllocationFunctions - Finds the overloads of operator new and delete
1722/// that are appropriate for the allocation.
Sebastian Redl1df2bbe2009-02-09 18:24:27 +00001723bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1724 bool UseGlobal, QualType AllocType,
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001725 bool IsArray, MultiExprArg PlaceArgs,
Sebastian Redlfaf68082008-12-03 20:26:15 +00001726 FunctionDecl *&OperatorNew,
Mike Stump11289f42009-09-09 15:08:12 +00001727 FunctionDecl *&OperatorDelete) {
Sebastian Redlfaf68082008-12-03 20:26:15 +00001728 // --- Choosing an allocation function ---
1729 // C++ 5.3.4p8 - 14 & 18
1730 // 1) If UseGlobal is true, only look in the global scope. Else, also look
1731 // in the scope of the allocated class.
1732 // 2) If an array size is given, look for operator new[], else look for
1733 // operator new.
1734 // 3) The first argument is always size_t. Append the arguments from the
1735 // placement form.
Sebastian Redlfaf68082008-12-03 20:26:15 +00001736
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001737 SmallVector<Expr*, 8> AllocArgs(1 + PlaceArgs.size());
Sebastian Redlfaf68082008-12-03 20:26:15 +00001738 // We don't care about the actual value of this argument.
1739 // FIXME: Should the Sema create the expression and embed it in the syntax
1740 // tree? Or should the consumer just recalculate the value?
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00001741 IntegerLiteral Size(Context, llvm::APInt::getNullValue(
Douglas Gregore8bbc122011-09-02 00:18:52 +00001742 Context.getTargetInfo().getPointerWidth(0)),
Anders Carlssona471db02009-08-16 20:29:29 +00001743 Context.getSizeType(),
1744 SourceLocation());
1745 AllocArgs[0] = &Size;
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001746 std::copy(PlaceArgs.begin(), PlaceArgs.end(), AllocArgs.begin() + 1);
Sebastian Redlfaf68082008-12-03 20:26:15 +00001747
Douglas Gregor6642ca22010-02-26 05:06:18 +00001748 // C++ [expr.new]p8:
1749 // If the allocated type is a non-array type, the allocation
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00001750 // function's name is operator new and the deallocation function's
Douglas Gregor6642ca22010-02-26 05:06:18 +00001751 // name is operator delete. If the allocated type is an array
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00001752 // type, the allocation function's name is operator new[] and the
1753 // deallocation function's name is operator delete[].
Sebastian Redlfaf68082008-12-03 20:26:15 +00001754 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
1755 IsArray ? OO_Array_New : OO_New);
Douglas Gregor6642ca22010-02-26 05:06:18 +00001756 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1757 IsArray ? OO_Array_Delete : OO_Delete);
1758
Argyrios Kyrtzidis1194d5e2010-08-25 23:14:56 +00001759 QualType AllocElemType = Context.getBaseElementType(AllocType);
1760
1761 if (AllocElemType->isRecordType() && !UseGlobal) {
Mike Stump11289f42009-09-09 15:08:12 +00001762 CXXRecordDecl *Record
Argyrios Kyrtzidis1194d5e2010-08-25 23:14:56 +00001763 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001764 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, Record,
1765 /*AllowMissing=*/true, OperatorNew))
Sebastian Redlfaf68082008-12-03 20:26:15 +00001766 return true;
Sebastian Redlfaf68082008-12-03 20:26:15 +00001767 }
Aaron Ballman324fbee2013-05-30 01:55:39 +00001768
Sebastian Redlfaf68082008-12-03 20:26:15 +00001769 if (!OperatorNew) {
1770 // Didn't find a member overload. Look for a global one.
1771 DeclareGlobalNewDelete();
Sebastian Redl33a31012008-12-04 22:20:51 +00001772 DeclContext *TUDecl = Context.getTranslationUnitDecl();
Alp Tokerbfa39342014-01-14 12:51:41 +00001773 bool FallbackEnabled = IsArray && Context.getLangOpts().MSVCCompat;
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001774 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
Aaron Ballman324fbee2013-05-30 01:55:39 +00001775 /*AllowMissing=*/FallbackEnabled, OperatorNew,
1776 /*Diagnose=*/!FallbackEnabled)) {
1777 if (!FallbackEnabled)
1778 return true;
1779
1780 // MSVC will fall back on trying to find a matching global operator new
1781 // if operator new[] cannot be found. Also, MSVC will leak by not
1782 // generating a call to operator delete or operator delete[], but we
1783 // will not replicate that bug.
1784 NewName = Context.DeclarationNames.getCXXOperatorName(OO_New);
1785 DeleteName = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
1786 if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001787 /*AllowMissing=*/false, OperatorNew))
Sebastian Redlfaf68082008-12-03 20:26:15 +00001788 return true;
Aaron Ballman324fbee2013-05-30 01:55:39 +00001789 }
Sebastian Redlfaf68082008-12-03 20:26:15 +00001790 }
1791
John McCall0f55a032010-04-20 02:18:25 +00001792 // We don't need an operator delete if we're running under
1793 // -fno-exceptions.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001794 if (!getLangOpts().Exceptions) {
Craig Topperc3ec1492014-05-26 06:22:03 +00001795 OperatorDelete = nullptr;
John McCall0f55a032010-04-20 02:18:25 +00001796 return false;
1797 }
1798
Douglas Gregor6642ca22010-02-26 05:06:18 +00001799 // C++ [expr.new]p19:
1800 //
1801 // If the new-expression begins with a unary :: operator, the
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00001802 // deallocation function's name is looked up in the global
Douglas Gregor6642ca22010-02-26 05:06:18 +00001803 // scope. Otherwise, if the allocated type is a class type T or an
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00001804 // array thereof, the deallocation function's name is looked up in
Douglas Gregor6642ca22010-02-26 05:06:18 +00001805 // the scope of T. If this lookup fails to find the name, or if
1806 // the allocated type is not a class type or array thereof, the
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00001807 // deallocation function's name is looked up in the global scope.
Douglas Gregor6642ca22010-02-26 05:06:18 +00001808 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
Argyrios Kyrtzidis1194d5e2010-08-25 23:14:56 +00001809 if (AllocElemType->isRecordType() && !UseGlobal) {
Douglas Gregor6642ca22010-02-26 05:06:18 +00001810 CXXRecordDecl *RD
Argyrios Kyrtzidis1194d5e2010-08-25 23:14:56 +00001811 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Douglas Gregor6642ca22010-02-26 05:06:18 +00001812 LookupQualifiedName(FoundDelete, RD);
1813 }
John McCallfb6f5262010-03-18 08:19:33 +00001814 if (FoundDelete.isAmbiguous())
1815 return true; // FIXME: clean up expressions?
Douglas Gregor6642ca22010-02-26 05:06:18 +00001816
1817 if (FoundDelete.empty()) {
1818 DeclareGlobalNewDelete();
1819 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
1820 }
1821
1822 FoundDelete.suppressDiagnostics();
John McCalla0296f72010-03-19 07:35:19 +00001823
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001824 SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
John McCalla0296f72010-03-19 07:35:19 +00001825
John McCalld3be2c82010-09-14 21:34:24 +00001826 // Whether we're looking for a placement operator delete is dictated
1827 // by whether we selected a placement operator new, not by whether
1828 // we had explicit placement arguments. This matters for things like
1829 // struct A { void *operator new(size_t, int = 0); ... };
1830 // A *a = new A()
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001831 bool isPlacementNew = (!PlaceArgs.empty() || OperatorNew->param_size() != 1);
John McCalld3be2c82010-09-14 21:34:24 +00001832
1833 if (isPlacementNew) {
Douglas Gregor6642ca22010-02-26 05:06:18 +00001834 // C++ [expr.new]p20:
1835 // A declaration of a placement deallocation function matches the
1836 // declaration of a placement allocation function if it has the
1837 // same number of parameters and, after parameter transformations
1838 // (8.3.5), all parameter types except the first are
1839 // identical. [...]
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001840 //
Douglas Gregor6642ca22010-02-26 05:06:18 +00001841 // To perform this comparison, we compute the function type that
1842 // the deallocation function should have, and use that type both
1843 // for template argument deduction and for comparison purposes.
John McCalldb40c7f2010-12-14 08:05:40 +00001844 //
1845 // FIXME: this comparison should ignore CC and the like.
Douglas Gregor6642ca22010-02-26 05:06:18 +00001846 QualType ExpectedFunctionType;
1847 {
1848 const FunctionProtoType *Proto
1849 = OperatorNew->getType()->getAs<FunctionProtoType>();
John McCalldb40c7f2010-12-14 08:05:40 +00001850
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001851 SmallVector<QualType, 4> ArgTypes;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001852 ArgTypes.push_back(Context.VoidPtrTy);
Alp Toker9cacbab2014-01-20 20:26:09 +00001853 for (unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
1854 ArgTypes.push_back(Proto->getParamType(I));
Douglas Gregor6642ca22010-02-26 05:06:18 +00001855
John McCalldb40c7f2010-12-14 08:05:40 +00001856 FunctionProtoType::ExtProtoInfo EPI;
1857 EPI.Variadic = Proto->isVariadic();
1858
Douglas Gregor6642ca22010-02-26 05:06:18 +00001859 ExpectedFunctionType
Jordan Rose5c382722013-03-08 21:51:21 +00001860 = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
Douglas Gregor6642ca22010-02-26 05:06:18 +00001861 }
1862
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001863 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6642ca22010-02-26 05:06:18 +00001864 DEnd = FoundDelete.end();
1865 D != DEnd; ++D) {
Craig Topperc3ec1492014-05-26 06:22:03 +00001866 FunctionDecl *Fn = nullptr;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001867 if (FunctionTemplateDecl *FnTmpl
Douglas Gregor6642ca22010-02-26 05:06:18 +00001868 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
1869 // Perform template argument deduction to try to match the
1870 // expected function type.
Craig Toppere6706e42012-09-19 02:26:47 +00001871 TemplateDeductionInfo Info(StartLoc);
Craig Topperc3ec1492014-05-26 06:22:03 +00001872 if (DeduceTemplateArguments(FnTmpl, nullptr, ExpectedFunctionType, Fn,
1873 Info))
Douglas Gregor6642ca22010-02-26 05:06:18 +00001874 continue;
1875 } else
1876 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
1877
1878 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
John McCalla0296f72010-03-19 07:35:19 +00001879 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6642ca22010-02-26 05:06:18 +00001880 }
1881 } else {
1882 // C++ [expr.new]p20:
1883 // [...] Any non-placement deallocation function matches a
1884 // non-placement allocation function. [...]
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001885 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6642ca22010-02-26 05:06:18 +00001886 DEnd = FoundDelete.end();
1887 D != DEnd; ++D) {
1888 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
Richard Smith1cdec012013-09-29 04:40:38 +00001889 if (isNonPlacementDeallocationFunction(*this, Fn))
John McCalla0296f72010-03-19 07:35:19 +00001890 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6642ca22010-02-26 05:06:18 +00001891 }
Richard Smith1cdec012013-09-29 04:40:38 +00001892
1893 // C++1y [expr.new]p22:
1894 // For a non-placement allocation function, the normal deallocation
1895 // function lookup is used
1896 // C++1y [expr.delete]p?:
1897 // If [...] deallocation function lookup finds both a usual deallocation
1898 // function with only a pointer parameter and a usual deallocation
1899 // function with both a pointer parameter and a size parameter, then the
1900 // selected deallocation function shall be the one with two parameters.
1901 // Otherwise, the selected deallocation function shall be the function
1902 // with one parameter.
1903 if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
1904 if (Matches[0].second->getNumParams() == 1)
1905 Matches.erase(Matches.begin());
1906 else
1907 Matches.erase(Matches.begin() + 1);
1908 assert(Matches[0].second->getNumParams() == 2 &&
Richard Smith2eaf2062014-02-03 07:04:10 +00001909 "found an unexpected usual deallocation function");
Richard Smith1cdec012013-09-29 04:40:38 +00001910 }
Douglas Gregor6642ca22010-02-26 05:06:18 +00001911 }
1912
1913 // C++ [expr.new]p20:
1914 // [...] If the lookup finds a single matching deallocation
1915 // function, that function will be called; otherwise, no
1916 // deallocation function will be called.
1917 if (Matches.size() == 1) {
John McCalla0296f72010-03-19 07:35:19 +00001918 OperatorDelete = Matches[0].second;
Douglas Gregor6642ca22010-02-26 05:06:18 +00001919
1920 // C++0x [expr.new]p20:
1921 // If the lookup finds the two-parameter form of a usual
1922 // deallocation function (3.7.4.2) and that function, considered
1923 // as a placement deallocation function, would have been
1924 // selected as a match for the allocation function, the program
1925 // is ill-formed.
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001926 if (!PlaceArgs.empty() && getLangOpts().CPlusPlus11 &&
Richard Smith1cdec012013-09-29 04:40:38 +00001927 isNonPlacementDeallocationFunction(*this, OperatorDelete)) {
Douglas Gregor6642ca22010-02-26 05:06:18 +00001928 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
Dmitri Gribenkobe022102013-05-10 13:22:23 +00001929 << SourceRange(PlaceArgs.front()->getLocStart(),
1930 PlaceArgs.back()->getLocEnd());
Richard Smith1cdec012013-09-29 04:40:38 +00001931 if (!OperatorDelete->isImplicit())
1932 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1933 << DeleteName;
John McCallfb6f5262010-03-18 08:19:33 +00001934 } else {
1935 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
John McCalla0296f72010-03-19 07:35:19 +00001936 Matches[0].first);
Douglas Gregor6642ca22010-02-26 05:06:18 +00001937 }
1938 }
1939
Sebastian Redlfaf68082008-12-03 20:26:15 +00001940 return false;
1941}
1942
Richard Smithd6f9e732014-05-13 19:56:21 +00001943/// \brief Find an fitting overload for the allocation function
1944/// in the specified scope.
1945///
1946/// \param StartLoc The location of the 'new' token.
NAKAMURA Takumi5182b5a2014-05-14 08:07:56 +00001947/// \param Range The range of the placement arguments.
Richard Smithd6f9e732014-05-13 19:56:21 +00001948/// \param Name The name of the function ('operator new' or 'operator new[]').
1949/// \param Args The placement arguments specified.
1950/// \param Ctx The scope in which we should search; either a class scope or the
1951/// translation unit.
1952/// \param AllowMissing If \c true, report an error if we can't find any
1953/// allocation functions. Otherwise, succeed but don't fill in \p
1954/// Operator.
1955/// \param Operator Filled in with the found allocation function. Unchanged if
1956/// no allocation function was found.
1957/// \param Diagnose If \c true, issue errors if the allocation function is not
1958/// usable.
Sebastian Redl1df2bbe2009-02-09 18:24:27 +00001959bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001960 DeclarationName Name, MultiExprArg Args,
1961 DeclContext *Ctx,
Alexis Hunt1f69a022011-05-12 22:46:29 +00001962 bool AllowMissing, FunctionDecl *&Operator,
1963 bool Diagnose) {
John McCall27b18f82009-11-17 02:14:36 +00001964 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1965 LookupQualifiedName(R, Ctx);
John McCall9f3059a2009-10-09 21:13:30 +00001966 if (R.empty()) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00001967 if (AllowMissing || !Diagnose)
Sebastian Redl33a31012008-12-04 22:20:51 +00001968 return false;
Sebastian Redl33a31012008-12-04 22:20:51 +00001969 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
Chris Lattner45d9d602009-02-17 07:29:20 +00001970 << Name << Range;
Sebastian Redl33a31012008-12-04 22:20:51 +00001971 }
1972
John McCallfb6f5262010-03-18 08:19:33 +00001973 if (R.isAmbiguous())
1974 return true;
1975
1976 R.suppressDiagnostics();
John McCall9f3059a2009-10-09 21:13:30 +00001977
Richard Smith100b24a2014-04-17 01:52:14 +00001978 OverloadCandidateSet Candidates(StartLoc, OverloadCandidateSet::CSK_Normal);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001979 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
Douglas Gregor80a6cc52009-09-30 00:03:47 +00001980 Alloc != AllocEnd; ++Alloc) {
Douglas Gregor55297ac2008-12-23 00:26:44 +00001981 // Even member operator new/delete are implicitly treated as
1982 // static, so don't use AddMemberCandidate.
John McCalla0296f72010-03-19 07:35:19 +00001983 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
Chandler Carruth93538422010-02-03 11:02:14 +00001984
John McCalla0296f72010-03-19 07:35:19 +00001985 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1986 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
Craig Topperc3ec1492014-05-26 06:22:03 +00001987 /*ExplicitTemplateArgs=*/nullptr,
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001988 Args, Candidates,
Chandler Carruth93538422010-02-03 11:02:14 +00001989 /*SuppressUserConversions=*/false);
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001990 continue;
Chandler Carruth93538422010-02-03 11:02:14 +00001991 }
1992
John McCalla0296f72010-03-19 07:35:19 +00001993 FunctionDecl *Fn = cast<FunctionDecl>(D);
Dmitri Gribenko08c86682013-05-10 00:20:06 +00001994 AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
Chandler Carruth93538422010-02-03 11:02:14 +00001995 /*SuppressUserConversions=*/false);
Sebastian Redl33a31012008-12-04 22:20:51 +00001996 }
1997
1998 // Do the resolution.
1999 OverloadCandidateSet::iterator Best;
John McCall5c32be02010-08-24 20:38:10 +00002000 switch (Candidates.BestViableFunction(*this, StartLoc, Best)) {
Sebastian Redl33a31012008-12-04 22:20:51 +00002001 case OR_Success: {
2002 // Got one!
2003 FunctionDecl *FnDecl = Best->Function;
Richard Smith921bd202012-02-26 09:11:52 +00002004 if (CheckAllocationAccess(StartLoc, Range, R.getNamingClass(),
2005 Best->FoundDecl, Diagnose) == AR_inaccessible)
2006 return true;
2007
Richard Smithd6f9e732014-05-13 19:56:21 +00002008 Operator = FnDecl;
Sebastian Redl33a31012008-12-04 22:20:51 +00002009 return false;
2010 }
2011
2012 case OR_No_Viable_Function:
Chandler Carruthe6c88182011-06-08 10:26:03 +00002013 if (Diagnose) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00002014 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
2015 << Name << Range;
Dmitri Gribenko08c86682013-05-10 00:20:06 +00002016 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
Chandler Carruthe6c88182011-06-08 10:26:03 +00002017 }
Sebastian Redl33a31012008-12-04 22:20:51 +00002018 return true;
2019
2020 case OR_Ambiguous:
Chandler Carruthe6c88182011-06-08 10:26:03 +00002021 if (Diagnose) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00002022 Diag(StartLoc, diag::err_ovl_ambiguous_call)
2023 << Name << Range;
Dmitri Gribenko08c86682013-05-10 00:20:06 +00002024 Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args);
Chandler Carruthe6c88182011-06-08 10:26:03 +00002025 }
Sebastian Redl33a31012008-12-04 22:20:51 +00002026 return true;
Douglas Gregor171c45a2009-02-18 21:56:37 +00002027
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002028 case OR_Deleted: {
Chandler Carruthe6c88182011-06-08 10:26:03 +00002029 if (Diagnose) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00002030 Diag(StartLoc, diag::err_ovl_deleted_call)
2031 << Best->Function->isDeleted()
2032 << Name
2033 << getDeletedOrUnavailableSuffix(Best->Function)
2034 << Range;
Dmitri Gribenko08c86682013-05-10 00:20:06 +00002035 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
Chandler Carruthe6c88182011-06-08 10:26:03 +00002036 }
Douglas Gregor171c45a2009-02-18 21:56:37 +00002037 return true;
Sebastian Redl33a31012008-12-04 22:20:51 +00002038 }
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002039 }
David Blaikie83d382b2011-09-23 05:06:16 +00002040 llvm_unreachable("Unreachable, bad result from BestViableFunction");
Sebastian Redl33a31012008-12-04 22:20:51 +00002041}
2042
2043
Sebastian Redlfaf68082008-12-03 20:26:15 +00002044/// DeclareGlobalNewDelete - Declare the global forms of operator new and
2045/// delete. These are:
2046/// @code
Sebastian Redl37588092011-03-14 18:08:30 +00002047/// // C++03:
Sebastian Redlfaf68082008-12-03 20:26:15 +00002048/// void* operator new(std::size_t) throw(std::bad_alloc);
2049/// void* operator new[](std::size_t) throw(std::bad_alloc);
2050/// void operator delete(void *) throw();
2051/// void operator delete[](void *) throw();
Richard Smith1cdec012013-09-29 04:40:38 +00002052/// // C++11:
Sebastian Redl37588092011-03-14 18:08:30 +00002053/// void* operator new(std::size_t);
2054/// void* operator new[](std::size_t);
Richard Smith1cdec012013-09-29 04:40:38 +00002055/// void operator delete(void *) noexcept;
2056/// void operator delete[](void *) noexcept;
2057/// // C++1y:
2058/// void* operator new(std::size_t);
2059/// void* operator new[](std::size_t);
2060/// void operator delete(void *) noexcept;
2061/// void operator delete[](void *) noexcept;
2062/// void operator delete(void *, std::size_t) noexcept;
2063/// void operator delete[](void *, std::size_t) noexcept;
Sebastian Redlfaf68082008-12-03 20:26:15 +00002064/// @endcode
2065/// Note that the placement and nothrow forms of new are *not* implicitly
2066/// declared. Their use requires including \<new\>.
Mike Stump11289f42009-09-09 15:08:12 +00002067void Sema::DeclareGlobalNewDelete() {
Sebastian Redlfaf68082008-12-03 20:26:15 +00002068 if (GlobalNewDeleteDeclared)
2069 return;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002070
Douglas Gregor87f54062009-09-15 22:30:29 +00002071 // C++ [basic.std.dynamic]p2:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002072 // [...] The following allocation and deallocation functions (18.4) are
2073 // implicitly declared in global scope in each translation unit of a
Douglas Gregor87f54062009-09-15 22:30:29 +00002074 // program
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002075 //
Sebastian Redl37588092011-03-14 18:08:30 +00002076 // C++03:
Douglas Gregor87f54062009-09-15 22:30:29 +00002077 // void* operator new(std::size_t) throw(std::bad_alloc);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002078 // void* operator new[](std::size_t) throw(std::bad_alloc);
2079 // void operator delete(void*) throw();
Douglas Gregor87f54062009-09-15 22:30:29 +00002080 // void operator delete[](void*) throw();
Richard Smith1cdec012013-09-29 04:40:38 +00002081 // C++11:
Sebastian Redl37588092011-03-14 18:08:30 +00002082 // void* operator new(std::size_t);
2083 // void* operator new[](std::size_t);
Richard Smith1cdec012013-09-29 04:40:38 +00002084 // void operator delete(void*) noexcept;
2085 // void operator delete[](void*) noexcept;
2086 // C++1y:
2087 // void* operator new(std::size_t);
2088 // void* operator new[](std::size_t);
2089 // void operator delete(void*) noexcept;
2090 // void operator delete[](void*) noexcept;
2091 // void operator delete(void*, std::size_t) noexcept;
2092 // void operator delete[](void*, std::size_t) noexcept;
Douglas Gregor87f54062009-09-15 22:30:29 +00002093 //
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002094 // These implicit declarations introduce only the function names operator
Douglas Gregor87f54062009-09-15 22:30:29 +00002095 // new, operator new[], operator delete, operator delete[].
2096 //
2097 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
2098 // "std" or "bad_alloc" as necessary to form the exception specification.
2099 // However, we do not make these implicit declarations visible to name
2100 // lookup.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002101 if (!StdBadAlloc && !getLangOpts().CPlusPlus11) {
Douglas Gregor87f54062009-09-15 22:30:29 +00002102 // The "std::bad_alloc" class has not yet been declared, so build it
2103 // implicitly.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002104 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
2105 getOrCreateStdNamespace(),
Abramo Bagnara29c2d462011-03-09 14:09:51 +00002106 SourceLocation(), SourceLocation(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002107 &PP.getIdentifierTable().get("bad_alloc"),
Craig Topperc3ec1492014-05-26 06:22:03 +00002108 nullptr);
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00002109 getStdBadAlloc()->setImplicit(true);
Douglas Gregor87f54062009-09-15 22:30:29 +00002110 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002111
Sebastian Redlfaf68082008-12-03 20:26:15 +00002112 GlobalNewDeleteDeclared = true;
2113
2114 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
2115 QualType SizeT = Context.getSizeType();
David Blaikiebbafb8a2012-03-11 07:00:24 +00002116 bool AssumeSaneOperatorNew = getLangOpts().AssumeSaneOperatorNew;
Sebastian Redlfaf68082008-12-03 20:26:15 +00002117
Sebastian Redlfaf68082008-12-03 20:26:15 +00002118 DeclareGlobalAllocationFunction(
2119 Context.DeclarationNames.getCXXOperatorName(OO_New),
Richard Smith1cdec012013-09-29 04:40:38 +00002120 VoidPtr, SizeT, QualType(), AssumeSaneOperatorNew);
Sebastian Redlfaf68082008-12-03 20:26:15 +00002121 DeclareGlobalAllocationFunction(
2122 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
Richard Smith1cdec012013-09-29 04:40:38 +00002123 VoidPtr, SizeT, QualType(), AssumeSaneOperatorNew);
Sebastian Redlfaf68082008-12-03 20:26:15 +00002124 DeclareGlobalAllocationFunction(
2125 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
2126 Context.VoidTy, VoidPtr);
2127 DeclareGlobalAllocationFunction(
2128 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
2129 Context.VoidTy, VoidPtr);
Richard Smith1cdec012013-09-29 04:40:38 +00002130 if (getLangOpts().SizedDeallocation) {
2131 DeclareGlobalAllocationFunction(
2132 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
2133 Context.VoidTy, VoidPtr, Context.getSizeType());
2134 DeclareGlobalAllocationFunction(
2135 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
2136 Context.VoidTy, VoidPtr, Context.getSizeType());
2137 }
Sebastian Redlfaf68082008-12-03 20:26:15 +00002138}
2139
2140/// DeclareGlobalAllocationFunction - Declares a single implicit global
2141/// allocation function if it doesn't already exist.
2142void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
Richard Smith1cdec012013-09-29 04:40:38 +00002143 QualType Return,
2144 QualType Param1, QualType Param2,
David Majnemer631a90b2015-02-04 07:23:21 +00002145 bool AddRestrictAttr) {
Sebastian Redlfaf68082008-12-03 20:26:15 +00002146 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
Richard Smith1cdec012013-09-29 04:40:38 +00002147 unsigned NumParams = Param2.isNull() ? 1 : 2;
Sebastian Redlfaf68082008-12-03 20:26:15 +00002148
2149 // Check if this function is already declared.
Serge Pavlovd5489072013-09-14 12:00:01 +00002150 DeclContext::lookup_result R = GlobalCtx->lookup(Name);
2151 for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end();
2152 Alloc != AllocEnd; ++Alloc) {
2153 // Only look at non-template functions, as it is the predefined,
2154 // non-templated allocation function we are trying to declare here.
2155 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
Richard Smith1cdec012013-09-29 04:40:38 +00002156 if (Func->getNumParams() == NumParams) {
2157 QualType InitialParam1Type =
2158 Context.getCanonicalType(Func->getParamDecl(0)
2159 ->getType().getUnqualifiedType());
2160 QualType InitialParam2Type =
2161 NumParams == 2
2162 ? Context.getCanonicalType(Func->getParamDecl(1)
2163 ->getType().getUnqualifiedType())
2164 : QualType();
Chandler Carruth93538422010-02-03 11:02:14 +00002165 // FIXME: Do we need to check for default arguments here?
Richard Smith1cdec012013-09-29 04:40:38 +00002166 if (InitialParam1Type == Param1 &&
2167 (NumParams == 1 || InitialParam2Type == Param2)) {
David Majnemer631a90b2015-02-04 07:23:21 +00002168 if (AddRestrictAttr && !Func->hasAttr<RestrictAttr>())
2169 Func->addAttr(RestrictAttr::CreateImplicit(
2170 Context, RestrictAttr::GNU_malloc));
Serge Pavlovd5489072013-09-14 12:00:01 +00002171 // Make the function visible to name lookup, even if we found it in
2172 // an unimported module. It either is an implicitly-declared global
Richard Smith42713d72013-07-14 02:01:48 +00002173 // allocation function, or is suppressing that function.
2174 Func->setHidden(false);
Chandler Carruth93538422010-02-03 11:02:14 +00002175 return;
Douglas Gregorc1a42fd2010-08-18 15:06:25 +00002176 }
Chandler Carruth93538422010-02-03 11:02:14 +00002177 }
Sebastian Redlfaf68082008-12-03 20:26:15 +00002178 }
2179 }
Reid Kleckner7270ef52015-03-19 17:03:58 +00002180
Richard Smithc015bc22014-02-07 22:39:53 +00002181 FunctionProtoType::ExtProtoInfo EPI;
2182
Richard Smithf8b417c2014-02-08 00:42:45 +00002183 QualType BadAllocType;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002184 bool HasBadAllocExceptionSpec
Douglas Gregor87f54062009-09-15 22:30:29 +00002185 = (Name.getCXXOverloadedOperator() == OO_New ||
2186 Name.getCXXOverloadedOperator() == OO_Array_New);
John McCalldb40c7f2010-12-14 08:05:40 +00002187 if (HasBadAllocExceptionSpec) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002188 if (!getLangOpts().CPlusPlus11) {
Richard Smithf8b417c2014-02-08 00:42:45 +00002189 BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
Richard Smithc015bc22014-02-07 22:39:53 +00002190 assert(StdBadAlloc && "Must have std::bad_alloc declared");
Richard Smith8acb4282014-07-31 21:57:55 +00002191 EPI.ExceptionSpec.Type = EST_Dynamic;
2192 EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType);
Sebastian Redl37588092011-03-14 18:08:30 +00002193 }
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002194 } else {
Richard Smith8acb4282014-07-31 21:57:55 +00002195 EPI.ExceptionSpec =
2196 getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
John McCalldb40c7f2010-12-14 08:05:40 +00002197 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002198
Richard Smith1cdec012013-09-29 04:40:38 +00002199 QualType Params[] = { Param1, Param2 };
2200
2201 QualType FnType = Context.getFunctionType(
Craig Topper5fc8fc22014-08-27 06:28:36 +00002202 Return, llvm::makeArrayRef(Params, NumParams), EPI);
Sebastian Redlfaf68082008-12-03 20:26:15 +00002203 FunctionDecl *Alloc =
Abramo Bagnaradff19302011-03-08 08:55:46 +00002204 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(),
2205 SourceLocation(), Name,
Craig Topperc3ec1492014-05-26 06:22:03 +00002206 FnType, /*TInfo=*/nullptr, SC_None, false, true);
Sebastian Redlfaf68082008-12-03 20:26:15 +00002207 Alloc->setImplicit();
Larisse Voufo404e1422015-02-04 02:34:32 +00002208
2209 // Implicit sized deallocation functions always have default visibility.
2210 Alloc->addAttr(VisibilityAttr::CreateImplicit(Context,
2211 VisibilityAttr::Default));
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002212
David Majnemer631a90b2015-02-04 07:23:21 +00002213 if (AddRestrictAttr)
2214 Alloc->addAttr(
2215 RestrictAttr::CreateImplicit(Context, RestrictAttr::GNU_malloc));
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002216
Richard Smith1cdec012013-09-29 04:40:38 +00002217 ParmVarDecl *ParamDecls[2];
Richard Smithbdd14642014-02-04 01:14:30 +00002218 for (unsigned I = 0; I != NumParams; ++I) {
Richard Smith1cdec012013-09-29 04:40:38 +00002219 ParamDecls[I] = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
Craig Topperc3ec1492014-05-26 06:22:03 +00002220 SourceLocation(), nullptr,
2221 Params[I], /*TInfo=*/nullptr,
2222 SC_None, nullptr);
Richard Smithbdd14642014-02-04 01:14:30 +00002223 ParamDecls[I]->setImplicit();
2224 }
Craig Topper5fc8fc22014-08-27 06:28:36 +00002225 Alloc->setParams(llvm::makeArrayRef(ParamDecls, NumParams));
Sebastian Redlfaf68082008-12-03 20:26:15 +00002226
John McCallcc14d1f2010-08-24 08:50:51 +00002227 Context.getTranslationUnitDecl()->addDecl(Alloc);
Richard Smithdebcd502014-05-16 02:14:42 +00002228 IdResolver.tryAddTopLevelDecl(Alloc, Name);
Sebastian Redlfaf68082008-12-03 20:26:15 +00002229}
2230
Richard Smith1cdec012013-09-29 04:40:38 +00002231FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
2232 bool CanProvideSize,
2233 DeclarationName Name) {
2234 DeclareGlobalNewDelete();
2235
2236 LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
2237 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
2238
2239 // C++ [expr.new]p20:
2240 // [...] Any non-placement deallocation function matches a
2241 // non-placement allocation function. [...]
2242 llvm::SmallVector<FunctionDecl*, 2> Matches;
2243 for (LookupResult::iterator D = FoundDelete.begin(),
2244 DEnd = FoundDelete.end();
2245 D != DEnd; ++D) {
2246 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>(*D))
2247 if (isNonPlacementDeallocationFunction(*this, Fn))
2248 Matches.push_back(Fn);
2249 }
2250
2251 // C++1y [expr.delete]p?:
2252 // If the type is complete and deallocation function lookup finds both a
2253 // usual deallocation function with only a pointer parameter and a usual
2254 // deallocation function with both a pointer parameter and a size
2255 // parameter, then the selected deallocation function shall be the one
2256 // with two parameters. Otherwise, the selected deallocation function
2257 // shall be the function with one parameter.
2258 if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
2259 unsigned NumArgs = CanProvideSize ? 2 : 1;
2260 if (Matches[0]->getNumParams() != NumArgs)
2261 Matches.erase(Matches.begin());
2262 else
2263 Matches.erase(Matches.begin() + 1);
2264 assert(Matches[0]->getNumParams() == NumArgs &&
Richard Smith2eaf2062014-02-03 07:04:10 +00002265 "found an unexpected usual deallocation function");
Richard Smith1cdec012013-09-29 04:40:38 +00002266 }
2267
Artem Belevich94a55e82015-09-22 17:22:59 +00002268 if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads)
2269 EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2270
Richard Smith1cdec012013-09-29 04:40:38 +00002271 assert(Matches.size() == 1 &&
2272 "unexpectedly have multiple usual deallocation functions");
2273 return Matches.front();
2274}
2275
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002276bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
2277 DeclarationName Name,
Alexis Hunt1f69a022011-05-12 22:46:29 +00002278 FunctionDecl* &Operator, bool Diagnose) {
John McCall27b18f82009-11-17 02:14:36 +00002279 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002280 // Try to find operator delete/operator delete[] in class scope.
John McCall27b18f82009-11-17 02:14:36 +00002281 LookupQualifiedName(Found, RD);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002282
John McCall27b18f82009-11-17 02:14:36 +00002283 if (Found.isAmbiguous())
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002284 return true;
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002285
Chandler Carruthb6f99172010-06-28 00:30:51 +00002286 Found.suppressDiagnostics();
2287
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002288 SmallVector<DeclAccessPair,4> Matches;
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002289 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
2290 F != FEnd; ++F) {
Chandler Carruth9b418232010-08-08 07:04:00 +00002291 NamedDecl *ND = (*F)->getUnderlyingDecl();
2292
2293 // Ignore template operator delete members from the check for a usual
2294 // deallocation function.
2295 if (isa<FunctionTemplateDecl>(ND))
2296 continue;
2297
2298 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction())
John McCall66a87592010-08-04 00:31:26 +00002299 Matches.push_back(F.getPair());
2300 }
2301
Artem Belevich94a55e82015-09-22 17:22:59 +00002302 if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads)
2303 EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2304
John McCall66a87592010-08-04 00:31:26 +00002305 // There's exactly one suitable operator; pick it.
2306 if (Matches.size() == 1) {
2307 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
Alexis Hunt1f69a022011-05-12 22:46:29 +00002308
2309 if (Operator->isDeleted()) {
2310 if (Diagnose) {
2311 Diag(StartLoc, diag::err_deleted_function_use);
Richard Smith852265f2012-03-30 20:53:28 +00002312 NoteDeletedFunction(Operator);
Alexis Hunt1f69a022011-05-12 22:46:29 +00002313 }
2314 return true;
2315 }
2316
Richard Smith921bd202012-02-26 09:11:52 +00002317 if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
2318 Matches[0], Diagnose) == AR_inaccessible)
2319 return true;
2320
John McCall66a87592010-08-04 00:31:26 +00002321 return false;
2322
2323 // We found multiple suitable operators; complain about the ambiguity.
2324 } else if (!Matches.empty()) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00002325 if (Diagnose) {
Alexis Huntf91729462011-05-12 22:46:25 +00002326 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2327 << Name << RD;
John McCall66a87592010-08-04 00:31:26 +00002328
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002329 for (SmallVectorImpl<DeclAccessPair>::iterator
Alexis Huntf91729462011-05-12 22:46:25 +00002330 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F)
2331 Diag((*F)->getUnderlyingDecl()->getLocation(),
2332 diag::note_member_declared_here) << Name;
2333 }
John McCall66a87592010-08-04 00:31:26 +00002334 return true;
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002335 }
2336
2337 // We did find operator delete/operator delete[] declarations, but
2338 // none of them were suitable.
2339 if (!Found.empty()) {
Alexis Hunt1f69a022011-05-12 22:46:29 +00002340 if (Diagnose) {
Alexis Huntf91729462011-05-12 22:46:25 +00002341 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2342 << Name << RD;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002343
Alexis Huntf91729462011-05-12 22:46:25 +00002344 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
2345 F != FEnd; ++F)
2346 Diag((*F)->getUnderlyingDecl()->getLocation(),
2347 diag::note_member_declared_here) << Name;
2348 }
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002349 return true;
2350 }
2351
Craig Topperc3ec1492014-05-26 06:22:03 +00002352 Operator = nullptr;
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002353 return false;
2354}
2355
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002356namespace {
2357/// \brief Checks whether delete-expression, and new-expression used for
2358/// initializing deletee have the same array form.
2359class MismatchingNewDeleteDetector {
2360public:
2361 enum MismatchResult {
2362 /// Indicates that there is no mismatch or a mismatch cannot be proven.
2363 NoMismatch,
2364 /// Indicates that variable is initialized with mismatching form of \a new.
2365 VarInitMismatches,
2366 /// Indicates that member is initialized with mismatching form of \a new.
2367 MemberInitMismatches,
2368 /// Indicates that 1 or more constructors' definitions could not been
2369 /// analyzed, and they will be checked again at the end of translation unit.
2370 AnalyzeLater
2371 };
2372
2373 /// \param EndOfTU True, if this is the final analysis at the end of
2374 /// translation unit. False, if this is the initial analysis at the point
2375 /// delete-expression was encountered.
2376 explicit MismatchingNewDeleteDetector(bool EndOfTU)
2377 : IsArrayForm(false), Field(nullptr), EndOfTU(EndOfTU),
2378 HasUndefinedConstructors(false) {}
2379
2380 /// \brief Checks whether pointee of a delete-expression is initialized with
2381 /// matching form of new-expression.
2382 ///
2383 /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the
2384 /// point where delete-expression is encountered, then a warning will be
2385 /// issued immediately. If return value is \c AnalyzeLater at the point where
2386 /// delete-expression is seen, then member will be analyzed at the end of
2387 /// translation unit. \c AnalyzeLater is returned iff at least one constructor
2388 /// couldn't be analyzed. If at least one constructor initializes the member
2389 /// with matching type of new, the return value is \c NoMismatch.
2390 MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE);
2391 /// \brief Analyzes a class member.
2392 /// \param Field Class member to analyze.
2393 /// \param DeleteWasArrayForm Array form-ness of the delete-expression used
2394 /// for deleting the \p Field.
2395 MismatchResult analyzeField(FieldDecl *Field, bool DeleteWasArrayForm);
2396 /// List of mismatching new-expressions used for initialization of the pointee
2397 llvm::SmallVector<const CXXNewExpr *, 4> NewExprs;
2398 /// Indicates whether delete-expression was in array form.
2399 bool IsArrayForm;
2400 FieldDecl *Field;
2401
2402private:
2403 const bool EndOfTU;
2404 /// \brief Indicates that there is at least one constructor without body.
2405 bool HasUndefinedConstructors;
2406 /// \brief Returns \c CXXNewExpr from given initialization expression.
2407 /// \param E Expression used for initializing pointee in delete-expression.
NAKAMURA Takumi4bd67d82015-05-19 06:47:23 +00002408 /// E can be a single-element \c InitListExpr consisting of new-expression.
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002409 const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E);
2410 /// \brief Returns whether member is initialized with mismatching form of
2411 /// \c new either by the member initializer or in-class initialization.
2412 ///
2413 /// If bodies of all constructors are not visible at the end of translation
2414 /// unit or at least one constructor initializes member with the matching
2415 /// form of \c new, mismatch cannot be proven, and this function will return
2416 /// \c NoMismatch.
2417 MismatchResult analyzeMemberExpr(const MemberExpr *ME);
2418 /// \brief Returns whether variable is initialized with mismatching form of
2419 /// \c new.
2420 ///
2421 /// If variable is initialized with matching form of \c new or variable is not
2422 /// initialized with a \c new expression, this function will return true.
2423 /// If variable is initialized with mismatching form of \c new, returns false.
2424 /// \param D Variable to analyze.
2425 bool hasMatchingVarInit(const DeclRefExpr *D);
2426 /// \brief Checks whether the constructor initializes pointee with mismatching
2427 /// form of \c new.
2428 ///
2429 /// Returns true, if member is initialized with matching form of \c new in
2430 /// member initializer list. Returns false, if member is initialized with the
2431 /// matching form of \c new in this constructor's initializer or given
2432 /// constructor isn't defined at the point where delete-expression is seen, or
2433 /// member isn't initialized by the constructor.
2434 bool hasMatchingNewInCtor(const CXXConstructorDecl *CD);
2435 /// \brief Checks whether member is initialized with matching form of
2436 /// \c new in member initializer list.
2437 bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI);
2438 /// Checks whether member is initialized with mismatching form of \c new by
2439 /// in-class initializer.
2440 MismatchResult analyzeInClassInitializer();
2441};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002442}
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002443
2444MismatchingNewDeleteDetector::MismatchResult
2445MismatchingNewDeleteDetector::analyzeDeleteExpr(const CXXDeleteExpr *DE) {
2446 NewExprs.clear();
2447 assert(DE && "Expected delete-expression");
2448 IsArrayForm = DE->isArrayForm();
2449 const Expr *E = DE->getArgument()->IgnoreParenImpCasts();
2450 if (const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
2451 return analyzeMemberExpr(ME);
2452 } else if (const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
2453 if (!hasMatchingVarInit(D))
2454 return VarInitMismatches;
2455 }
2456 return NoMismatch;
2457}
2458
2459const CXXNewExpr *
2460MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) {
2461 assert(E != nullptr && "Expected a valid initializer expression");
2462 E = E->IgnoreParenImpCasts();
2463 if (const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
2464 if (ILE->getNumInits() == 1)
2465 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
2466 }
2467
2468 return dyn_cast_or_null<const CXXNewExpr>(E);
2469}
2470
2471bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
2472 const CXXCtorInitializer *CI) {
2473 const CXXNewExpr *NE = nullptr;
2474 if (Field == CI->getMember() &&
2475 (NE = getNewExprFromInitListOrExpr(CI->getInit()))) {
2476 if (NE->isArray() == IsArrayForm)
2477 return true;
2478 else
2479 NewExprs.push_back(NE);
2480 }
2481 return false;
2482}
2483
2484bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
2485 const CXXConstructorDecl *CD) {
2486 if (CD->isImplicit())
2487 return false;
2488 const FunctionDecl *Definition = CD;
2489 if (!CD->isThisDeclarationADefinition() && !CD->isDefined(Definition)) {
2490 HasUndefinedConstructors = true;
2491 return EndOfTU;
2492 }
2493 for (const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
2494 if (hasMatchingNewInCtorInit(CI))
2495 return true;
2496 }
2497 return false;
2498}
2499
2500MismatchingNewDeleteDetector::MismatchResult
2501MismatchingNewDeleteDetector::analyzeInClassInitializer() {
2502 assert(Field != nullptr && "This should be called only for members");
Ismail Pazarbasi7ff18362015-10-26 19:20:24 +00002503 const Expr *InitExpr = Field->getInClassInitializer();
2504 if (!InitExpr)
2505 return EndOfTU ? NoMismatch : AnalyzeLater;
2506 if (const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002507 if (NE->isArray() != IsArrayForm) {
2508 NewExprs.push_back(NE);
2509 return MemberInitMismatches;
2510 }
2511 }
2512 return NoMismatch;
2513}
2514
2515MismatchingNewDeleteDetector::MismatchResult
2516MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field,
2517 bool DeleteWasArrayForm) {
2518 assert(Field != nullptr && "Analysis requires a valid class member.");
2519 this->Field = Field;
2520 IsArrayForm = DeleteWasArrayForm;
2521 const CXXRecordDecl *RD = cast<const CXXRecordDecl>(Field->getParent());
2522 for (const auto *CD : RD->ctors()) {
2523 if (hasMatchingNewInCtor(CD))
2524 return NoMismatch;
2525 }
2526 if (HasUndefinedConstructors)
2527 return EndOfTU ? NoMismatch : AnalyzeLater;
2528 if (!NewExprs.empty())
2529 return MemberInitMismatches;
2530 return Field->hasInClassInitializer() ? analyzeInClassInitializer()
2531 : NoMismatch;
2532}
2533
2534MismatchingNewDeleteDetector::MismatchResult
2535MismatchingNewDeleteDetector::analyzeMemberExpr(const MemberExpr *ME) {
2536 assert(ME != nullptr && "Expected a member expression");
2537 if (FieldDecl *F = dyn_cast<FieldDecl>(ME->getMemberDecl()))
2538 return analyzeField(F, IsArrayForm);
2539 return NoMismatch;
2540}
2541
2542bool MismatchingNewDeleteDetector::hasMatchingVarInit(const DeclRefExpr *D) {
2543 const CXXNewExpr *NE = nullptr;
2544 if (const VarDecl *VD = dyn_cast<const VarDecl>(D->getDecl())) {
2545 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
2546 NE->isArray() != IsArrayForm) {
2547 NewExprs.push_back(NE);
2548 }
2549 }
2550 return NewExprs.empty();
2551}
2552
2553static void
2554DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc,
2555 const MismatchingNewDeleteDetector &Detector) {
2556 SourceLocation EndOfDelete = SemaRef.getLocForEndOfToken(DeleteLoc);
2557 FixItHint H;
2558 if (!Detector.IsArrayForm)
2559 H = FixItHint::CreateInsertion(EndOfDelete, "[]");
2560 else {
2561 SourceLocation RSquare = Lexer::findLocationAfterToken(
2562 DeleteLoc, tok::l_square, SemaRef.getSourceManager(),
2563 SemaRef.getLangOpts(), true);
2564 if (RSquare.isValid())
2565 H = FixItHint::CreateRemoval(SourceRange(EndOfDelete, RSquare));
2566 }
2567 SemaRef.Diag(DeleteLoc, diag::warn_mismatched_delete_new)
2568 << Detector.IsArrayForm << H;
2569
2570 for (const auto *NE : Detector.NewExprs)
2571 SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here)
2572 << Detector.IsArrayForm;
2573}
2574
2575void Sema::AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE) {
2576 if (Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation()))
2577 return;
2578 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/false);
2579 switch (Detector.analyzeDeleteExpr(DE)) {
2580 case MismatchingNewDeleteDetector::VarInitMismatches:
2581 case MismatchingNewDeleteDetector::MemberInitMismatches: {
2582 DiagnoseMismatchedNewDelete(*this, DE->getLocStart(), Detector);
2583 break;
2584 }
2585 case MismatchingNewDeleteDetector::AnalyzeLater: {
2586 DeleteExprs[Detector.Field].push_back(
2587 std::make_pair(DE->getLocStart(), DE->isArrayForm()));
2588 break;
2589 }
2590 case MismatchingNewDeleteDetector::NoMismatch:
2591 break;
2592 }
2593}
2594
2595void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
2596 bool DeleteWasArrayForm) {
2597 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/true);
2598 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
2599 case MismatchingNewDeleteDetector::VarInitMismatches:
2600 llvm_unreachable("This analysis should have been done for class members.");
2601 case MismatchingNewDeleteDetector::AnalyzeLater:
2602 llvm_unreachable("Analysis cannot be postponed any point beyond end of "
2603 "translation unit.");
2604 case MismatchingNewDeleteDetector::MemberInitMismatches:
2605 DiagnoseMismatchedNewDelete(*this, DeleteLoc, Detector);
2606 break;
2607 case MismatchingNewDeleteDetector::NoMismatch:
2608 break;
2609 }
2610}
2611
Sebastian Redlbd150f42008-11-21 19:14:01 +00002612/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
2613/// @code ::delete ptr; @endcode
2614/// or
2615/// @code delete [] ptr; @endcode
John McCalldadc5752010-08-24 06:29:42 +00002616ExprResult
Sebastian Redlbd150f42008-11-21 19:14:01 +00002617Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
John Wiegley01296292011-04-08 18:41:53 +00002618 bool ArrayForm, Expr *ExE) {
Douglas Gregor0fea62d2009-09-09 23:39:55 +00002619 // C++ [expr.delete]p1:
2620 // The operand shall have a pointer type, or a class type having a single
Richard Smithccc11812013-05-21 19:05:48 +00002621 // non-explicit conversion function to a pointer type. The result has type
2622 // void.
Douglas Gregor0fea62d2009-09-09 23:39:55 +00002623 //
Sebastian Redlbd150f42008-11-21 19:14:01 +00002624 // DR599 amends "pointer type" to "pointer to object type" in both cases.
2625
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00002626 ExprResult Ex = ExE;
Craig Topperc3ec1492014-05-26 06:22:03 +00002627 FunctionDecl *OperatorDelete = nullptr;
Argyrios Kyrtzidis14ec9f62010-09-13 20:15:54 +00002628 bool ArrayFormAsWritten = ArrayForm;
John McCall284c48f2011-01-27 09:37:56 +00002629 bool UsualArrayDeleteWantsSize = false;
Mike Stump11289f42009-09-09 15:08:12 +00002630
John Wiegley01296292011-04-08 18:41:53 +00002631 if (!Ex.get()->isTypeDependent()) {
John McCallef429022012-03-09 04:08:29 +00002632 // Perform lvalue-to-rvalue cast, if needed.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002633 Ex = DefaultLvalueConversion(Ex.get());
Eli Friedman89a4a2c2012-12-13 00:37:17 +00002634 if (Ex.isInvalid())
2635 return ExprError();
John McCallef429022012-03-09 04:08:29 +00002636
John Wiegley01296292011-04-08 18:41:53 +00002637 QualType Type = Ex.get()->getType();
Sebastian Redlbd150f42008-11-21 19:14:01 +00002638
Richard Smithccc11812013-05-21 19:05:48 +00002639 class DeleteConverter : public ContextualImplicitConverter {
2640 public:
2641 DeleteConverter() : ContextualImplicitConverter(false, true) {}
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002642
Craig Toppere14c0f82014-03-12 04:55:44 +00002643 bool match(QualType ConvType) override {
Richard Smithccc11812013-05-21 19:05:48 +00002644 // FIXME: If we have an operator T* and an operator void*, we must pick
2645 // the operator T*.
Douglas Gregor0fea62d2009-09-09 23:39:55 +00002646 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
Eli Friedmana170cd62010-08-05 02:49:48 +00002647 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
Richard Smithccc11812013-05-21 19:05:48 +00002648 return true;
2649 return false;
Douglas Gregor0fea62d2009-09-09 23:39:55 +00002650 }
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002651
Richard Smithccc11812013-05-21 19:05:48 +00002652 SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc,
Craig Toppere14c0f82014-03-12 04:55:44 +00002653 QualType T) override {
Richard Smithccc11812013-05-21 19:05:48 +00002654 return S.Diag(Loc, diag::err_delete_operand) << T;
2655 }
2656
2657 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
Craig Toppere14c0f82014-03-12 04:55:44 +00002658 QualType T) override {
Richard Smithccc11812013-05-21 19:05:48 +00002659 return S.Diag(Loc, diag::err_delete_incomplete_class_type) << T;
2660 }
2661
2662 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
Craig Toppere14c0f82014-03-12 04:55:44 +00002663 QualType T,
2664 QualType ConvTy) override {
Richard Smithccc11812013-05-21 19:05:48 +00002665 return S.Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
2666 }
2667
2668 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
Craig Toppere14c0f82014-03-12 04:55:44 +00002669 QualType ConvTy) override {
Richard Smithccc11812013-05-21 19:05:48 +00002670 return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
2671 << ConvTy;
2672 }
2673
2674 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
Craig Toppere14c0f82014-03-12 04:55:44 +00002675 QualType T) override {
Richard Smithccc11812013-05-21 19:05:48 +00002676 return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T;
2677 }
2678
2679 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
Craig Toppere14c0f82014-03-12 04:55:44 +00002680 QualType ConvTy) override {
Richard Smithccc11812013-05-21 19:05:48 +00002681 return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
2682 << ConvTy;
2683 }
2684
2685 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
Craig Toppere14c0f82014-03-12 04:55:44 +00002686 QualType T,
2687 QualType ConvTy) override {
Richard Smithccc11812013-05-21 19:05:48 +00002688 llvm_unreachable("conversion functions are permitted");
2689 }
2690 } Converter;
2691
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002692 Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter);
Richard Smithccc11812013-05-21 19:05:48 +00002693 if (Ex.isInvalid())
2694 return ExprError();
2695 Type = Ex.get()->getType();
2696 if (!Converter.match(Type))
2697 // FIXME: PerformContextualImplicitConversion should return ExprError
2698 // itself in this case.
2699 return ExprError();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002700
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002701 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
Eli Friedmanae4280f2011-07-26 22:25:31 +00002702 QualType PointeeElem = Context.getBaseElementType(Pointee);
2703
2704 if (unsigned AddressSpace = Pointee.getAddressSpace())
2705 return Diag(Ex.get()->getLocStart(),
2706 diag::err_address_space_qualified_delete)
2707 << Pointee.getUnqualifiedType() << AddressSpace;
2708
Craig Topperc3ec1492014-05-26 06:22:03 +00002709 CXXRecordDecl *PointeeRD = nullptr;
Douglas Gregorbb3348e2010-05-24 17:01:56 +00002710 if (Pointee->isVoidType() && !isSFINAEContext()) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002711 // The C++ standard bans deleting a pointer to a non-object type, which
Douglas Gregorbb3348e2010-05-24 17:01:56 +00002712 // effectively bans deletion of "void*". However, most compilers support
2713 // this, so we treat it as a warning unless we're in a SFINAE context.
2714 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
John Wiegley01296292011-04-08 18:41:53 +00002715 << Type << Ex.get()->getSourceRange();
Eli Friedmanae4280f2011-07-26 22:25:31 +00002716 } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
Sebastian Redl6d4256c2009-03-15 17:47:39 +00002717 return ExprError(Diag(StartLoc, diag::err_delete_operand)
John Wiegley01296292011-04-08 18:41:53 +00002718 << Type << Ex.get()->getSourceRange());
Eli Friedmanae4280f2011-07-26 22:25:31 +00002719 } else if (!Pointee->isDependentType()) {
Richard Smithdb0ac552015-12-18 22:40:25 +00002720 // FIXME: This can result in errors if the definition was imported from a
2721 // module but is hidden.
Eli Friedmanae4280f2011-07-26 22:25:31 +00002722 if (!RequireCompleteType(StartLoc, Pointee,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00002723 diag::warn_delete_incomplete, Ex.get())) {
Eli Friedmanae4280f2011-07-26 22:25:31 +00002724 if (const RecordType *RT = PointeeElem->getAs<RecordType>())
2725 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
2726 }
2727 }
2728
Argyrios Kyrtzidis14ec9f62010-09-13 20:15:54 +00002729 if (Pointee->isArrayType() && !ArrayForm) {
2730 Diag(StartLoc, diag::warn_delete_array_type)
John Wiegley01296292011-04-08 18:41:53 +00002731 << Type << Ex.get()->getSourceRange()
Craig Topper07fa1762015-11-15 02:31:46 +00002732 << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), "[]");
Argyrios Kyrtzidis14ec9f62010-09-13 20:15:54 +00002733 ArrayForm = true;
2734 }
2735
Anders Carlssona471db02009-08-16 20:29:29 +00002736 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
2737 ArrayForm ? OO_Array_Delete : OO_Delete);
2738
Eli Friedmanae4280f2011-07-26 22:25:31 +00002739 if (PointeeRD) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002740 if (!UseGlobal &&
Eli Friedmanae4280f2011-07-26 22:25:31 +00002741 FindDeallocationFunction(StartLoc, PointeeRD, DeleteName,
2742 OperatorDelete))
Anders Carlsson654e5c72009-11-14 03:17:38 +00002743 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002744
John McCall284c48f2011-01-27 09:37:56 +00002745 // If we're allocating an array of records, check whether the
2746 // usual operator delete[] has a size_t parameter.
2747 if (ArrayForm) {
2748 // If the user specifically asked to use the global allocator,
2749 // we'll need to do the lookup into the class.
2750 if (UseGlobal)
2751 UsualArrayDeleteWantsSize =
2752 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
2753
2754 // Otherwise, the usual operator delete[] should be the
2755 // function we just found.
Richard Smithf03bd302013-12-05 08:30:59 +00002756 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
John McCall284c48f2011-01-27 09:37:56 +00002757 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2);
2758 }
2759
Richard Smitheec915d62012-02-18 04:13:32 +00002760 if (!PointeeRD->hasIrrelevantDestructor())
Eli Friedmanae4280f2011-07-26 22:25:31 +00002761 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
Eli Friedmanfa0df832012-02-02 03:46:19 +00002762 MarkFunctionReferenced(StartLoc,
Fariborz Jahanian37d06562009-09-03 23:18:17 +00002763 const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith22262ab2013-05-04 06:44:46 +00002764 if (DiagnoseUseOfDecl(Dtor, StartLoc))
2765 return ExprError();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002766 }
Argyrios Kyrtzidis8bd42852011-05-24 19:53:26 +00002767
2768 // C++ [expr.delete]p3:
2769 // In the first alternative (delete object), if the static type of the
2770 // object to be deleted is different from its dynamic type, the static
2771 // type shall be a base class of the dynamic type of the object to be
2772 // deleted and the static type shall have a virtual destructor or the
2773 // behavior is undefined.
2774 //
2775 // Note: a final class cannot be derived from, no issue there
Eli Friedman1b71a222011-07-26 23:27:24 +00002776 if (PointeeRD->isPolymorphic() && !PointeeRD->hasAttr<FinalAttr>()) {
Eli Friedmanae4280f2011-07-26 22:25:31 +00002777 CXXDestructorDecl *dtor = PointeeRD->getDestructor();
Eli Friedman1b71a222011-07-26 23:27:24 +00002778 if (dtor && !dtor->isVirtual()) {
2779 if (PointeeRD->isAbstract()) {
2780 // If the class is abstract, we warn by default, because we're
2781 // sure the code has undefined behavior.
2782 Diag(StartLoc, diag::warn_delete_abstract_non_virtual_dtor)
2783 << PointeeElem;
2784 } else if (!ArrayForm) {
2785 // Otherwise, if this is not an array delete, it's a bit suspect,
2786 // but not necessarily wrong.
2787 Diag(StartLoc, diag::warn_delete_non_virtual_dtor) << PointeeElem;
2788 }
2789 }
Argyrios Kyrtzidis8bd42852011-05-24 19:53:26 +00002790 }
John McCall31168b02011-06-15 23:02:42 +00002791
Anders Carlssona471db02009-08-16 20:29:29 +00002792 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002793
Richard Smith1cdec012013-09-29 04:40:38 +00002794 if (!OperatorDelete)
Anders Carlssone1d34ba02009-11-15 18:45:20 +00002795 // Look for a global declaration.
Richard Smith1cdec012013-09-29 04:40:38 +00002796 OperatorDelete = FindUsualDeallocationFunction(
Richard Smithdb0ac552015-12-18 22:40:25 +00002797 StartLoc, isCompleteType(StartLoc, Pointee) &&
Richard Smith1cdec012013-09-29 04:40:38 +00002798 (!ArrayForm || UsualArrayDeleteWantsSize ||
2799 Pointee.isDestructedType()),
2800 DeleteName);
Mike Stump11289f42009-09-09 15:08:12 +00002801
Eli Friedmanfa0df832012-02-02 03:46:19 +00002802 MarkFunctionReferenced(StartLoc, OperatorDelete);
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002803
Douglas Gregorfa778132011-02-01 15:50:11 +00002804 // Check access and ambiguity of operator delete and destructor.
Eli Friedmanae4280f2011-07-26 22:25:31 +00002805 if (PointeeRD) {
2806 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
John Wiegley01296292011-04-08 18:41:53 +00002807 CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
Douglas Gregorfa778132011-02-01 15:50:11 +00002808 PDiag(diag::err_access_dtor) << PointeeElem);
2809 }
2810 }
Sebastian Redlbd150f42008-11-21 19:14:01 +00002811 }
2812
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002813 CXXDeleteExpr *Result = new (Context) CXXDeleteExpr(
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00002814 Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten,
2815 UsualArrayDeleteWantsSize, OperatorDelete, Ex.get(), StartLoc);
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002816 AnalyzeDeleteExprMismatch(Result);
2817 return Result;
Sebastian Redlbd150f42008-11-21 19:14:01 +00002818}
2819
Douglas Gregor633caca2009-11-23 23:44:04 +00002820/// \brief Check the use of the given variable as a C++ condition in an if,
2821/// while, do-while, or switch statement.
John McCalldadc5752010-08-24 06:29:42 +00002822ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
John McCall7decc9e2010-11-18 06:31:45 +00002823 SourceLocation StmtLoc,
2824 bool ConvertToBoolean) {
Richard Smith27d807c2013-04-30 13:56:41 +00002825 if (ConditionVar->isInvalidDecl())
2826 return ExprError();
2827
Douglas Gregor633caca2009-11-23 23:44:04 +00002828 QualType T = ConditionVar->getType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002829
Douglas Gregor633caca2009-11-23 23:44:04 +00002830 // C++ [stmt.select]p2:
2831 // The declarator shall not specify a function or an array.
2832 if (T->isFunctionType())
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002833 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor633caca2009-11-23 23:44:04 +00002834 diag::err_invalid_use_of_function_type)
2835 << ConditionVar->getSourceRange());
2836 else if (T->isArrayType())
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002837 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor633caca2009-11-23 23:44:04 +00002838 diag::err_invalid_use_of_array_type)
2839 << ConditionVar->getSourceRange());
Douglas Gregor0156d1c2009-11-24 16:07:02 +00002840
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00002841 ExprResult Condition = DeclRefExpr::Create(
2842 Context, NestedNameSpecifierLoc(), SourceLocation(), ConditionVar,
2843 /*enclosing*/ false, ConditionVar->getLocation(),
2844 ConditionVar->getType().getNonReferenceType(), VK_LValue);
Eli Friedman2dfa7932012-01-16 21:00:51 +00002845
Eli Friedmanfa0df832012-02-02 03:46:19 +00002846 MarkDeclRefReferenced(cast<DeclRefExpr>(Condition.get()));
Eli Friedman2dfa7932012-01-16 21:00:51 +00002847
John Wiegley01296292011-04-08 18:41:53 +00002848 if (ConvertToBoolean) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002849 Condition = CheckBooleanCondition(Condition.get(), StmtLoc);
John Wiegley01296292011-04-08 18:41:53 +00002850 if (Condition.isInvalid())
2851 return ExprError();
2852 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002853
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002854 return Condition;
Douglas Gregor633caca2009-11-23 23:44:04 +00002855}
2856
Argyrios Kyrtzidis7620ee42008-09-10 02:17:11 +00002857/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
John Wiegley01296292011-04-08 18:41:53 +00002858ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr) {
Argyrios Kyrtzidis7620ee42008-09-10 02:17:11 +00002859 // C++ 6.4p4:
2860 // The value of a condition that is an initialized declaration in a statement
2861 // other than a switch statement is the value of the declared variable
2862 // implicitly converted to type bool. If that conversion is ill-formed, the
2863 // program is ill-formed.
2864 // The value of a condition that is an expression is the value of the
2865 // expression, implicitly converted to bool.
2866 //
Douglas Gregor5fb53972009-01-14 15:45:31 +00002867 return PerformContextuallyConvertToBool(CondExpr);
Argyrios Kyrtzidis7620ee42008-09-10 02:17:11 +00002868}
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00002869
2870/// Helper function to determine whether this is the (deprecated) C++
2871/// conversion from a string literal to a pointer to non-const char or
2872/// non-const wchar_t (for narrow and wide string literals,
2873/// respectively).
Mike Stump11289f42009-09-09 15:08:12 +00002874bool
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00002875Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
2876 // Look inside the implicit cast, if it exists.
2877 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
2878 From = Cast->getSubExpr();
2879
2880 // A string literal (2.13.4) that is not a wide string literal can
2881 // be converted to an rvalue of type "pointer to char"; a wide
2882 // string literal can be converted to an rvalue of type "pointer
2883 // to wchar_t" (C++ 4.2p2).
Douglas Gregor689999d2010-06-22 23:47:37 +00002884 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002885 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
Mike Stump11289f42009-09-09 15:08:12 +00002886 if (const BuiltinType *ToPointeeType
John McCall9dd450b2009-09-21 23:43:11 +00002887 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00002888 // This conversion is considered only when there is an
2889 // explicit appropriate pointer target type (C++ 4.2p2).
Douglas Gregorfb65e592011-07-27 05:40:30 +00002890 if (!ToPtrType->getPointeeType().hasQualifiers()) {
2891 switch (StrLit->getKind()) {
2892 case StringLiteral::UTF8:
2893 case StringLiteral::UTF16:
2894 case StringLiteral::UTF32:
2895 // We don't allow UTF literals to be implicitly converted
2896 break;
2897 case StringLiteral::Ascii:
2898 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
2899 ToPointeeType->getKind() == BuiltinType::Char_S);
2900 case StringLiteral::Wide:
2901 return ToPointeeType->isWideCharType();
2902 }
2903 }
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00002904 }
2905
2906 return false;
2907}
Douglas Gregor39c16d42008-10-24 04:54:22 +00002908
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002909static ExprResult BuildCXXCastArgument(Sema &S,
John McCalle3027922010-08-25 11:45:40 +00002910 SourceLocation CastLoc,
2911 QualType Ty,
2912 CastKind Kind,
2913 CXXMethodDecl *Method,
John McCall30909032011-09-21 08:36:56 +00002914 DeclAccessPair FoundDecl,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00002915 bool HadMultipleCandidates,
John McCalle3027922010-08-25 11:45:40 +00002916 Expr *From) {
Douglas Gregora4253922010-04-16 22:17:36 +00002917 switch (Kind) {
David Blaikie83d382b2011-09-23 05:06:16 +00002918 default: llvm_unreachable("Unhandled cast kind!");
John McCalle3027922010-08-25 11:45:40 +00002919 case CK_ConstructorConversion: {
Douglas Gregorc7a31072011-10-10 22:41:00 +00002920 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
Benjamin Kramerf0623432012-08-23 22:51:59 +00002921 SmallVector<Expr*, 8> ConstructorArgs;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002922
Richard Smith72d74052013-07-20 19:41:36 +00002923 if (S.RequireNonAbstractType(CastLoc, Ty,
2924 diag::err_allocation_of_abstract_type))
2925 return ExprError();
2926
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00002927 if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
John McCallfaf5fb42010-08-26 23:41:50 +00002928 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002929
John McCall5dadb652012-04-07 03:04:20 +00002930 S.CheckConstructorAccess(CastLoc, Constructor,
2931 InitializedEntity::InitializeTemporary(Ty),
2932 Constructor->getAccess());
Richard Smith7c9442a2015-02-24 21:44:43 +00002933 if (S.DiagnoseUseOfDecl(Method, CastLoc))
Richard Smithd3f2d322015-02-24 21:16:19 +00002934 return ExprError();
Richard Smithd59b8322012-12-19 01:39:02 +00002935
Richard Smithf8adcdc2014-07-17 05:12:35 +00002936 ExprResult Result = S.BuildCXXConstructExpr(
2937 CastLoc, Ty, cast<CXXConstructorDecl>(Method),
2938 ConstructorArgs, HadMultipleCandidates,
2939 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
2940 CXXConstructExpr::CK_Complete, SourceRange());
Douglas Gregora4253922010-04-16 22:17:36 +00002941 if (Result.isInvalid())
John McCallfaf5fb42010-08-26 23:41:50 +00002942 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002943
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002944 return S.MaybeBindToTemporary(Result.getAs<Expr>());
Douglas Gregora4253922010-04-16 22:17:36 +00002945 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002946
John McCalle3027922010-08-25 11:45:40 +00002947 case CK_UserDefinedConversion: {
Douglas Gregora4253922010-04-16 22:17:36 +00002948 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002949
Richard Smithd3f2d322015-02-24 21:16:19 +00002950 S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl);
Richard Smith7c9442a2015-02-24 21:44:43 +00002951 if (S.DiagnoseUseOfDecl(Method, CastLoc))
Richard Smithd3f2d322015-02-24 21:16:19 +00002952 return ExprError();
2953
Douglas Gregora4253922010-04-16 22:17:36 +00002954 // Create an implicit call expr that calls it.
Eli Friedman2fb85122012-03-01 01:30:04 +00002955 CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
2956 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00002957 HadMultipleCandidates);
Douglas Gregor668443e2011-01-20 00:18:04 +00002958 if (Result.isInvalid())
2959 return ExprError();
Abramo Bagnarab0cf2972011-11-16 22:46:05 +00002960 // Record usage of conversion in an implicit cast.
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00002961 Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(),
2962 CK_UserDefinedConversion, Result.get(),
2963 nullptr, Result.get()->getValueKind());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002964
Douglas Gregor668443e2011-01-20 00:18:04 +00002965 return S.MaybeBindToTemporary(Result.get());
Douglas Gregora4253922010-04-16 22:17:36 +00002966 }
2967 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002968}
Douglas Gregora4253922010-04-16 22:17:36 +00002969
Douglas Gregor5fb53972009-01-14 15:45:31 +00002970/// PerformImplicitConversion - Perform an implicit conversion of the
2971/// expression From to the type ToType using the pre-computed implicit
John Wiegley01296292011-04-08 18:41:53 +00002972/// conversion sequence ICS. Returns the converted
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00002973/// expression. Action is the kind of conversion we're performing,
Douglas Gregor5fb53972009-01-14 15:45:31 +00002974/// used in the error message.
John Wiegley01296292011-04-08 18:41:53 +00002975ExprResult
2976Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor5fb53972009-01-14 15:45:31 +00002977 const ImplicitConversionSequence &ICS,
John McCall31168b02011-06-15 23:02:42 +00002978 AssignmentAction Action,
2979 CheckedConversionKind CCK) {
John McCall0d1da222010-01-12 00:44:57 +00002980 switch (ICS.getKind()) {
John Wiegley01296292011-04-08 18:41:53 +00002981 case ImplicitConversionSequence::StandardConversion: {
Richard Smith507840d2011-11-29 22:48:16 +00002982 ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
2983 Action, CCK);
John Wiegley01296292011-04-08 18:41:53 +00002984 if (Res.isInvalid())
2985 return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002986 From = Res.get();
Douglas Gregor39c16d42008-10-24 04:54:22 +00002987 break;
John Wiegley01296292011-04-08 18:41:53 +00002988 }
Douglas Gregor39c16d42008-10-24 04:54:22 +00002989
Anders Carlsson110b07b2009-09-15 06:28:28 +00002990 case ImplicitConversionSequence::UserDefinedConversion: {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002991
Fariborz Jahanian2fee79a2009-08-28 22:04:50 +00002992 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
John McCall8cb679e2010-11-15 09:13:47 +00002993 CastKind CastKind;
Anders Carlsson110b07b2009-09-15 06:28:28 +00002994 QualType BeforeToType;
Richard Smithd3f2d322015-02-24 21:16:19 +00002995 assert(FD && "no conversion function for user-defined conversion seq");
Anders Carlsson110b07b2009-09-15 06:28:28 +00002996 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
John McCalle3027922010-08-25 11:45:40 +00002997 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002998
Anders Carlsson110b07b2009-09-15 06:28:28 +00002999 // If the user-defined conversion is specified by a conversion function,
3000 // the initial standard conversion sequence converts the source type to
3001 // the implicit object parameter of the conversion function.
3002 BeforeToType = Context.getTagDeclType(Conv->getParent());
John McCalla03edda2010-12-04 09:57:16 +00003003 } else {
3004 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
John McCalle3027922010-08-25 11:45:40 +00003005 CastKind = CK_ConstructorConversion;
Fariborz Jahanian55824512009-11-06 00:23:08 +00003006 // Do no conversion if dealing with ... for the first conversion.
Douglas Gregor3153da72009-11-20 02:31:03 +00003007 if (!ICS.UserDefined.EllipsisConversion) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003008 // If the user-defined conversion is specified by a constructor, the
Nico Weberb58e51c2014-11-19 05:21:39 +00003009 // initial standard conversion sequence converts the source type to
3010 // the type required by the argument of the constructor
Douglas Gregor3153da72009-11-20 02:31:03 +00003011 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
3012 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003013 }
Richard Smith72d74052013-07-20 19:41:36 +00003014 // Watch out for ellipsis conversion.
Fariborz Jahanianeec642f2009-11-06 00:55:14 +00003015 if (!ICS.UserDefined.EllipsisConversion) {
John Wiegley01296292011-04-08 18:41:53 +00003016 ExprResult Res =
Richard Smith507840d2011-11-29 22:48:16 +00003017 PerformImplicitConversion(From, BeforeToType,
3018 ICS.UserDefined.Before, AA_Converting,
3019 CCK);
John Wiegley01296292011-04-08 18:41:53 +00003020 if (Res.isInvalid())
3021 return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003022 From = Res.get();
Fariborz Jahanian55824512009-11-06 00:23:08 +00003023 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003024
3025 ExprResult CastArg
Douglas Gregora4253922010-04-16 22:17:36 +00003026 = BuildCXXCastArgument(*this,
3027 From->getLocStart(),
Anders Carlssone9766d52009-09-09 21:33:21 +00003028 ToType.getNonReferenceType(),
Douglas Gregor2bbfba02011-01-20 01:32:05 +00003029 CastKind, cast<CXXMethodDecl>(FD),
3030 ICS.UserDefined.FoundConversionFunction,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00003031 ICS.UserDefined.HadMultipleCandidates,
John McCallb268a282010-08-23 23:25:46 +00003032 From);
Anders Carlssone9766d52009-09-09 21:33:21 +00003033
3034 if (CastArg.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00003035 return ExprError();
Eli Friedmane96f1d32009-11-27 04:41:50 +00003036
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003037 From = CastArg.get();
Eli Friedmane96f1d32009-11-27 04:41:50 +00003038
Richard Smith507840d2011-11-29 22:48:16 +00003039 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
3040 AA_Converting, CCK);
Fariborz Jahanianda21efb2009-10-16 19:20:59 +00003041 }
John McCall0d1da222010-01-12 00:44:57 +00003042
3043 case ImplicitConversionSequence::AmbiguousConversion:
John McCall5c32be02010-08-24 20:38:10 +00003044 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
John McCall0d1da222010-01-12 00:44:57 +00003045 PDiag(diag::err_typecheck_ambiguous_condition)
3046 << From->getSourceRange());
John Wiegley01296292011-04-08 18:41:53 +00003047 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003048
Douglas Gregor39c16d42008-10-24 04:54:22 +00003049 case ImplicitConversionSequence::EllipsisConversion:
David Blaikie83d382b2011-09-23 05:06:16 +00003050 llvm_unreachable("Cannot perform an ellipsis conversion");
Douglas Gregor39c16d42008-10-24 04:54:22 +00003051
3052 case ImplicitConversionSequence::BadConversion:
John Wiegley01296292011-04-08 18:41:53 +00003053 return ExprError();
Douglas Gregor39c16d42008-10-24 04:54:22 +00003054 }
3055
3056 // Everything went well.
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00003057 return From;
Douglas Gregor39c16d42008-10-24 04:54:22 +00003058}
3059
Richard Smith507840d2011-11-29 22:48:16 +00003060/// PerformImplicitConversion - Perform an implicit conversion of the
Douglas Gregor39c16d42008-10-24 04:54:22 +00003061/// expression From to the type ToType by following the standard
John Wiegley01296292011-04-08 18:41:53 +00003062/// conversion sequence SCS. Returns the converted
Douglas Gregor47d3f272008-12-19 17:40:08 +00003063/// expression. Flavor is the context in which we're performing this
3064/// conversion, for use in error messages.
John Wiegley01296292011-04-08 18:41:53 +00003065ExprResult
Richard Smith507840d2011-11-29 22:48:16 +00003066Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor47d3f272008-12-19 17:40:08 +00003067 const StandardConversionSequence& SCS,
John McCall31168b02011-06-15 23:02:42 +00003068 AssignmentAction Action,
3069 CheckedConversionKind CCK) {
3070 bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast);
3071
Mike Stump87c57ac2009-05-16 07:39:55 +00003072 // Overall FIXME: we are recomputing too many types here and doing far too
3073 // much extra work. What this means is that we need to keep track of more
3074 // information that is computed when we try the implicit conversion initially,
3075 // so that we don't need to recompute anything here.
Douglas Gregor39c16d42008-10-24 04:54:22 +00003076 QualType FromType = From->getType();
John McCall31168b02011-06-15 23:02:42 +00003077
Douglas Gregor2fe98832008-11-03 19:09:14 +00003078 if (SCS.CopyConstructor) {
Anders Carlsson549c5bd2009-05-19 04:45:15 +00003079 // FIXME: When can ToType be a reference type?
3080 assert(!ToType->isReferenceType());
Fariborz Jahanian49850df2009-09-25 18:59:21 +00003081 if (SCS.Second == ICK_Derived_To_Base) {
Benjamin Kramerf0623432012-08-23 22:51:59 +00003082 SmallVector<Expr*, 8> ConstructorArgs;
Fariborz Jahanian49850df2009-09-25 18:59:21 +00003083 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00003084 From, /*FIXME:ConstructLoc*/SourceLocation(),
Fariborz Jahanian49850df2009-09-25 18:59:21 +00003085 ConstructorArgs))
John Wiegley01296292011-04-08 18:41:53 +00003086 return ExprError();
Richard Smithf8adcdc2014-07-17 05:12:35 +00003087 return BuildCXXConstructExpr(
3088 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, SCS.CopyConstructor,
3089 ConstructorArgs, /*HadMultipleCandidates*/ false,
3090 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3091 CXXConstructExpr::CK_Complete, SourceRange());
Fariborz Jahanian49850df2009-09-25 18:59:21 +00003092 }
Richard Smithf8adcdc2014-07-17 05:12:35 +00003093 return BuildCXXConstructExpr(
3094 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, SCS.CopyConstructor,
3095 From, /*HadMultipleCandidates*/ false,
3096 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3097 CXXConstructExpr::CK_Complete, SourceRange());
Douglas Gregor2fe98832008-11-03 19:09:14 +00003098 }
3099
Douglas Gregor980fb162010-04-29 18:24:40 +00003100 // Resolve overloaded function references.
3101 if (Context.hasSameType(FromType, Context.OverloadTy)) {
3102 DeclAccessPair Found;
3103 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
3104 true, Found);
3105 if (!Fn)
John Wiegley01296292011-04-08 18:41:53 +00003106 return ExprError();
Douglas Gregor980fb162010-04-29 18:24:40 +00003107
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003108 if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
John Wiegley01296292011-04-08 18:41:53 +00003109 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003110
Douglas Gregor980fb162010-04-29 18:24:40 +00003111 From = FixOverloadedFunctionReference(From, Found, Fn);
3112 FromType = From->getType();
3113 }
3114
Richard Smitha23ab512013-05-23 00:30:41 +00003115 // If we're converting to an atomic type, first convert to the corresponding
3116 // non-atomic type.
3117 QualType ToAtomicType;
3118 if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
3119 ToAtomicType = ToType;
3120 ToType = ToAtomic->getValueType();
3121 }
3122
George Burgess IV8d141e02015-12-14 22:00:49 +00003123 QualType InitialFromType = FromType;
Richard Smith507840d2011-11-29 22:48:16 +00003124 // Perform the first implicit conversion.
Douglas Gregor39c16d42008-10-24 04:54:22 +00003125 switch (SCS.First) {
3126 case ICK_Identity:
David Majnemer3087a2b2014-12-28 21:47:31 +00003127 if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
3128 FromType = FromAtomic->getValueType().getUnqualifiedType();
3129 From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
3130 From, /*BasePath=*/nullptr, VK_RValue);
3131 }
Douglas Gregor39c16d42008-10-24 04:54:22 +00003132 break;
3133
Eli Friedman946b7b52012-01-24 22:51:26 +00003134 case ICK_Lvalue_To_Rvalue: {
John McCall526ab472011-10-25 17:37:35 +00003135 assert(From->getObjectKind() != OK_ObjCProperty);
Eli Friedman946b7b52012-01-24 22:51:26 +00003136 ExprResult FromRes = DefaultLvalueConversion(From);
3137 assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003138 From = FromRes.get();
David Majnemere7029bc2014-12-16 06:31:17 +00003139 FromType = From->getType();
John McCall34376a62010-12-04 03:47:34 +00003140 break;
Eli Friedman946b7b52012-01-24 22:51:26 +00003141 }
John McCall34376a62010-12-04 03:47:34 +00003142
Douglas Gregor39c16d42008-10-24 04:54:22 +00003143 case ICK_Array_To_Pointer:
Douglas Gregor171c45a2009-02-18 21:56:37 +00003144 FromType = Context.getArrayDecayedType(FromType);
Richard Smith507840d2011-11-29 22:48:16 +00003145 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003146 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor171c45a2009-02-18 21:56:37 +00003147 break;
3148
3149 case ICK_Function_To_Pointer:
Douglas Gregor39c16d42008-10-24 04:54:22 +00003150 FromType = Context.getPointerType(FromType);
Richard Smith507840d2011-11-29 22:48:16 +00003151 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003152 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor39c16d42008-10-24 04:54:22 +00003153 break;
3154
3155 default:
David Blaikie83d382b2011-09-23 05:06:16 +00003156 llvm_unreachable("Improper first standard conversion");
Douglas Gregor39c16d42008-10-24 04:54:22 +00003157 }
3158
Richard Smith507840d2011-11-29 22:48:16 +00003159 // Perform the second implicit conversion
Douglas Gregor39c16d42008-10-24 04:54:22 +00003160 switch (SCS.Second) {
3161 case ICK_Identity:
Richard Smith410cc892014-11-26 03:26:53 +00003162 // C++ [except.spec]p5:
3163 // [For] assignment to and initialization of pointers to functions,
3164 // pointers to member functions, and references to functions: the
3165 // target entity shall allow at least the exceptions allowed by the
3166 // source value in the assignment or initialization.
3167 switch (Action) {
3168 case AA_Assigning:
3169 case AA_Initializing:
3170 // Note, function argument passing and returning are initialization.
3171 case AA_Passing:
3172 case AA_Returning:
3173 case AA_Sending:
3174 case AA_Passing_CFAudited:
3175 if (CheckExceptionSpecCompatibility(From, ToType))
3176 return ExprError();
3177 break;
3178
3179 case AA_Casting:
3180 case AA_Converting:
3181 // Casts and implicit conversions are not initialization, so are not
3182 // checked for exception specification mismatches.
3183 break;
3184 }
Sebastian Redl5d431642009-10-10 12:04:10 +00003185 // Nothing else to do.
Douglas Gregor39c16d42008-10-24 04:54:22 +00003186 break;
3187
Douglas Gregor40cb9ad2009-12-09 00:47:37 +00003188 case ICK_NoReturn_Adjustment:
3189 // If both sides are functions (or pointers/references to them), there could
3190 // be incompatible exception declarations.
3191 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley01296292011-04-08 18:41:53 +00003192 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003193
Richard Smith507840d2011-11-29 22:48:16 +00003194 From = ImpCastExprToType(From, ToType, CK_NoOp,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003195 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor40cb9ad2009-12-09 00:47:37 +00003196 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003197
Douglas Gregor39c16d42008-10-24 04:54:22 +00003198 case ICK_Integral_Promotion:
Douglas Gregor39c16d42008-10-24 04:54:22 +00003199 case ICK_Integral_Conversion:
Richard Smithb9c5a602012-09-13 21:18:54 +00003200 if (ToType->isBooleanType()) {
3201 assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
3202 SCS.Second == ICK_Integral_Promotion &&
3203 "only enums with fixed underlying type can promote to bool");
3204 From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003205 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Richard Smithb9c5a602012-09-13 21:18:54 +00003206 } else {
3207 From = ImpCastExprToType(From, ToType, CK_IntegralCast,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003208 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Richard Smithb9c5a602012-09-13 21:18:54 +00003209 }
Eli Friedman06ed2a52009-10-20 08:27:19 +00003210 break;
3211
3212 case ICK_Floating_Promotion:
Douglas Gregor39c16d42008-10-24 04:54:22 +00003213 case ICK_Floating_Conversion:
Richard Smith507840d2011-11-29 22:48:16 +00003214 From = ImpCastExprToType(From, ToType, CK_FloatingCast,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003215 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00003216 break;
3217
3218 case ICK_Complex_Promotion:
John McCall8cb679e2010-11-15 09:13:47 +00003219 case ICK_Complex_Conversion: {
3220 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
3221 QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
3222 CastKind CK;
3223 if (FromEl->isRealFloatingType()) {
3224 if (ToEl->isRealFloatingType())
3225 CK = CK_FloatingComplexCast;
3226 else
3227 CK = CK_FloatingComplexToIntegralComplex;
3228 } else if (ToEl->isRealFloatingType()) {
3229 CK = CK_IntegralComplexToFloatingComplex;
3230 } else {
3231 CK = CK_IntegralComplexCast;
3232 }
Richard Smith507840d2011-11-29 22:48:16 +00003233 From = ImpCastExprToType(From, ToType, CK,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003234 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00003235 break;
John McCall8cb679e2010-11-15 09:13:47 +00003236 }
Eli Friedman06ed2a52009-10-20 08:27:19 +00003237
Douglas Gregor39c16d42008-10-24 04:54:22 +00003238 case ICK_Floating_Integral:
Douglas Gregor49b4d732010-06-22 23:07:26 +00003239 if (ToType->isRealFloatingType())
Richard Smith507840d2011-11-29 22:48:16 +00003240 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003241 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00003242 else
Richard Smith507840d2011-11-29 22:48:16 +00003243 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003244 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00003245 break;
3246
Douglas Gregor4e5cbdc2009-02-11 23:02:49 +00003247 case ICK_Compatible_Conversion:
Richard Smith507840d2011-11-29 22:48:16 +00003248 From = ImpCastExprToType(From, ToType, CK_NoOp,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003249 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor39c16d42008-10-24 04:54:22 +00003250 break;
3251
John McCall31168b02011-06-15 23:02:42 +00003252 case ICK_Writeback_Conversion:
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00003253 case ICK_Pointer_Conversion: {
Douglas Gregor6dd3a6a2010-12-02 21:47:04 +00003254 if (SCS.IncompatibleObjC && Action != AA_Casting) {
Douglas Gregor47d3f272008-12-19 17:40:08 +00003255 // Diagnose incompatible Objective-C conversions
Douglas Gregor2720dc62011-06-11 04:42:12 +00003256 if (Action == AA_Initializing || Action == AA_Assigning)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003257 Diag(From->getLocStart(),
Fariborz Jahanian413e0642011-03-21 19:08:42 +00003258 diag::ext_typecheck_convert_incompatible_pointer)
3259 << ToType << From->getType() << Action
Anna Zaks3b402712011-07-28 19:51:27 +00003260 << From->getSourceRange() << 0;
Fariborz Jahanian413e0642011-03-21 19:08:42 +00003261 else
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003262 Diag(From->getLocStart(),
Fariborz Jahanian413e0642011-03-21 19:08:42 +00003263 diag::ext_typecheck_convert_incompatible_pointer)
3264 << From->getType() << ToType << Action
Anna Zaks3b402712011-07-28 19:51:27 +00003265 << From->getSourceRange() << 0;
John McCall31168b02011-06-15 23:02:42 +00003266
Douglas Gregor33823722011-06-11 01:09:30 +00003267 if (From->getType()->isObjCObjectPointerType() &&
3268 ToType->isObjCObjectPointerType())
3269 EmitRelatedResultTypeNote(From);
Fariborz Jahanianf2913402011-07-08 17:41:42 +00003270 }
David Blaikiebbafb8a2012-03-11 07:00:24 +00003271 else if (getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanianf2913402011-07-08 17:41:42 +00003272 !CheckObjCARCUnavailableWeakConversion(ToType,
3273 From->getType())) {
John McCall9c3467e2011-09-09 06:12:06 +00003274 if (Action == AA_Initializing)
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003275 Diag(From->getLocStart(),
John McCall9c3467e2011-09-09 06:12:06 +00003276 diag::err_arc_weak_unavailable_assign);
3277 else
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003278 Diag(From->getLocStart(),
John McCall9c3467e2011-09-09 06:12:06 +00003279 diag::err_arc_convesion_of_weak_unavailable)
3280 << (Action == AA_Casting) << From->getType() << ToType
3281 << From->getSourceRange();
3282 }
Fariborz Jahanianf2913402011-07-08 17:41:42 +00003283
John McCall8cb679e2010-11-15 09:13:47 +00003284 CastKind Kind = CK_Invalid;
John McCallcf142162010-08-07 06:22:56 +00003285 CXXCastPath BasePath;
Douglas Gregor58281352011-01-27 00:58:17 +00003286 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley01296292011-04-08 18:41:53 +00003287 return ExprError();
John McCallcd78e802011-09-10 01:16:55 +00003288
3289 // Make sure we extend blocks if necessary.
3290 // FIXME: doing this here is really ugly.
3291 if (Kind == CK_BlockPointerToObjCPointerCast) {
3292 ExprResult E = From;
3293 (void) PrepareCastToObjCObjectPointer(E);
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003294 From = E.get();
John McCallcd78e802011-09-10 01:16:55 +00003295 }
Fariborz Jahanian374089e2013-07-31 17:12:26 +00003296 if (getLangOpts().ObjCAutoRefCount)
3297 CheckObjCARCConversion(SourceRange(), ToType, From, CCK);
Richard Smith507840d2011-11-29 22:48:16 +00003298 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003299 .get();
Douglas Gregor39c16d42008-10-24 04:54:22 +00003300 break;
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00003301 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003302
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00003303 case ICK_Pointer_Member: {
John McCall8cb679e2010-11-15 09:13:47 +00003304 CastKind Kind = CK_Invalid;
John McCallcf142162010-08-07 06:22:56 +00003305 CXXCastPath BasePath;
Douglas Gregor58281352011-01-27 00:58:17 +00003306 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley01296292011-04-08 18:41:53 +00003307 return ExprError();
Sebastian Redl5d431642009-10-10 12:04:10 +00003308 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley01296292011-04-08 18:41:53 +00003309 return ExprError();
David Majnemerd96b9972014-08-08 00:10:39 +00003310
3311 // We may not have been able to figure out what this member pointer resolved
3312 // to up until this exact point. Attempt to lock-in it's inheritance model.
David Majnemerfc22e472015-06-12 17:55:44 +00003313 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
Richard Smithdb0ac552015-12-18 22:40:25 +00003314 (void)isCompleteType(From->getExprLoc(), From->getType());
3315 (void)isCompleteType(From->getExprLoc(), ToType);
David Majnemerfc22e472015-06-12 17:55:44 +00003316 }
David Majnemerd96b9972014-08-08 00:10:39 +00003317
Richard Smith507840d2011-11-29 22:48:16 +00003318 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003319 .get();
Anders Carlsson7ec8ccd2009-09-12 04:46:44 +00003320 break;
3321 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003322
Abramo Bagnara7ccce982011-04-07 09:26:19 +00003323 case ICK_Boolean_Conversion:
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00003324 // Perform half-to-boolean conversion via float.
3325 if (From->getType()->isHalfType()) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003326 From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get();
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00003327 FromType = Context.FloatTy;
3328 }
3329
Richard Smith507840d2011-11-29 22:48:16 +00003330 From = ImpCastExprToType(From, Context.BoolTy,
3331 ScalarTypeToBooleanCastKind(FromType),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003332 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor39c16d42008-10-24 04:54:22 +00003333 break;
3334
Douglas Gregor88d292c2010-05-13 16:44:06 +00003335 case ICK_Derived_To_Base: {
John McCallcf142162010-08-07 06:22:56 +00003336 CXXCastPath BasePath;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003337 if (CheckDerivedToBaseConversion(From->getType(),
Douglas Gregor02ba0ea2009-11-06 01:02:41 +00003338 ToType.getNonReferenceType(),
3339 From->getLocStart(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003340 From->getSourceRange(),
Douglas Gregor88d292c2010-05-13 16:44:06 +00003341 &BasePath,
Douglas Gregor58281352011-01-27 00:58:17 +00003342 CStyle))
John Wiegley01296292011-04-08 18:41:53 +00003343 return ExprError();
Douglas Gregor88d292c2010-05-13 16:44:06 +00003344
Richard Smith507840d2011-11-29 22:48:16 +00003345 From = ImpCastExprToType(From, ToType.getNonReferenceType(),
3346 CK_DerivedToBase, From->getValueKind(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003347 &BasePath, CCK).get();
Douglas Gregor02ba0ea2009-11-06 01:02:41 +00003348 break;
Douglas Gregor88d292c2010-05-13 16:44:06 +00003349 }
3350
Douglas Gregor46188682010-05-18 22:42:18 +00003351 case ICK_Vector_Conversion:
Richard Smith507840d2011-11-29 22:48:16 +00003352 From = ImpCastExprToType(From, ToType, CK_BitCast,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003353 VK_RValue, /*BasePath=*/nullptr, CCK).get();
Douglas Gregor46188682010-05-18 22:42:18 +00003354 break;
3355
George Burgess IVdf1ed002016-01-13 01:52:39 +00003356 case ICK_Vector_Splat: {
Fariborz Jahanian28d94b12015-03-05 23:06:09 +00003357 // Vector splat from any arithmetic type to a vector.
George Burgess IVdf1ed002016-01-13 01:52:39 +00003358 Expr *Elem = prepareVectorSplat(ToType, From).get();
3359 From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_RValue,
3360 /*BasePath=*/nullptr, CCK).get();
Douglas Gregor46188682010-05-18 22:42:18 +00003361 break;
George Burgess IVdf1ed002016-01-13 01:52:39 +00003362 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003363
Douglas Gregor46188682010-05-18 22:42:18 +00003364 case ICK_Complex_Real:
John McCall8cb679e2010-11-15 09:13:47 +00003365 // Case 1. x -> _Complex y
3366 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
3367 QualType ElType = ToComplex->getElementType();
3368 bool isFloatingComplex = ElType->isRealFloatingType();
3369
3370 // x -> y
3371 if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
3372 // do nothing
3373 } else if (From->getType()->isRealFloatingType()) {
Richard Smith507840d2011-11-29 22:48:16 +00003374 From = ImpCastExprToType(From, ElType,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003375 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get();
John McCall8cb679e2010-11-15 09:13:47 +00003376 } else {
3377 assert(From->getType()->isIntegerType());
Richard Smith507840d2011-11-29 22:48:16 +00003378 From = ImpCastExprToType(From, ElType,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003379 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get();
John McCall8cb679e2010-11-15 09:13:47 +00003380 }
3381 // y -> _Complex y
Richard Smith507840d2011-11-29 22:48:16 +00003382 From = ImpCastExprToType(From, ToType,
3383 isFloatingComplex ? CK_FloatingRealToComplex
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003384 : CK_IntegralRealToComplex).get();
John McCall8cb679e2010-11-15 09:13:47 +00003385
3386 // Case 2. _Complex x -> y
3387 } else {
3388 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
3389 assert(FromComplex);
3390
3391 QualType ElType = FromComplex->getElementType();
3392 bool isFloatingComplex = ElType->isRealFloatingType();
3393
3394 // _Complex x -> x
Richard Smith507840d2011-11-29 22:48:16 +00003395 From = ImpCastExprToType(From, ElType,
3396 isFloatingComplex ? CK_FloatingComplexToReal
3397 : CK_IntegralComplexToReal,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003398 VK_RValue, /*BasePath=*/nullptr, CCK).get();
John McCall8cb679e2010-11-15 09:13:47 +00003399
3400 // x -> y
3401 if (Context.hasSameUnqualifiedType(ElType, ToType)) {
3402 // do nothing
3403 } else if (ToType->isRealFloatingType()) {
Richard Smith507840d2011-11-29 22:48:16 +00003404 From = ImpCastExprToType(From, ToType,
3405 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003406 VK_RValue, /*BasePath=*/nullptr, CCK).get();
John McCall8cb679e2010-11-15 09:13:47 +00003407 } else {
3408 assert(ToType->isIntegerType());
Richard Smith507840d2011-11-29 22:48:16 +00003409 From = ImpCastExprToType(From, ToType,
3410 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003411 VK_RValue, /*BasePath=*/nullptr, CCK).get();
John McCall8cb679e2010-11-15 09:13:47 +00003412 }
3413 }
Douglas Gregor46188682010-05-18 22:42:18 +00003414 break;
Fariborz Jahanian42455ea2011-02-12 19:07:46 +00003415
3416 case ICK_Block_Pointer_Conversion: {
Richard Smith507840d2011-11-29 22:48:16 +00003417 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003418 VK_RValue, /*BasePath=*/nullptr, CCK).get();
John McCall31168b02011-06-15 23:02:42 +00003419 break;
3420 }
Fariborz Jahanian42455ea2011-02-12 19:07:46 +00003421
Fariborz Jahanian16f92ce2011-03-23 19:50:54 +00003422 case ICK_TransparentUnionConversion: {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00003423 ExprResult FromRes = From;
Fariborz Jahanian16f92ce2011-03-23 19:50:54 +00003424 Sema::AssignConvertType ConvTy =
John Wiegley01296292011-04-08 18:41:53 +00003425 CheckTransparentUnionArgumentConstraints(ToType, FromRes);
3426 if (FromRes.isInvalid())
3427 return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003428 From = FromRes.get();
Fariborz Jahanian16f92ce2011-03-23 19:50:54 +00003429 assert ((ConvTy == Sema::Compatible) &&
3430 "Improper transparent union conversion");
3431 (void)ConvTy;
3432 break;
3433 }
3434
Guy Benyei259f9f42013-02-07 16:05:33 +00003435 case ICK_Zero_Event_Conversion:
3436 From = ImpCastExprToType(From, ToType,
3437 CK_ZeroToOCLEvent,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003438 From->getValueKind()).get();
Guy Benyei259f9f42013-02-07 16:05:33 +00003439 break;
3440
Douglas Gregor46188682010-05-18 22:42:18 +00003441 case ICK_Lvalue_To_Rvalue:
3442 case ICK_Array_To_Pointer:
3443 case ICK_Function_To_Pointer:
3444 case ICK_Qualification:
3445 case ICK_Num_Conversion_Kinds:
George Burgess IV78ed9b42015-10-11 20:37:14 +00003446 case ICK_C_Only_Conversion:
David Blaikie83d382b2011-09-23 05:06:16 +00003447 llvm_unreachable("Improper second standard conversion");
Douglas Gregor39c16d42008-10-24 04:54:22 +00003448 }
3449
3450 switch (SCS.Third) {
3451 case ICK_Identity:
3452 // Nothing to do.
3453 break;
3454
Sebastian Redlc57d34b2010-07-20 04:20:21 +00003455 case ICK_Qualification: {
3456 // The qualification keeps the category of the inner expression, unless the
3457 // target type isn't a reference.
John McCall2536c6d2010-08-25 10:28:54 +00003458 ExprValueKind VK = ToType->isReferenceType() ?
Eli Friedmanbe4b3632011-09-27 21:58:52 +00003459 From->getValueKind() : VK_RValue;
Richard Smith507840d2011-11-29 22:48:16 +00003460 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003461 CK_NoOp, VK, /*BasePath=*/nullptr, CCK).get();
Douglas Gregore489a7d2010-02-28 18:30:25 +00003462
Douglas Gregore981bb02011-03-14 16:13:32 +00003463 if (SCS.DeprecatedStringLiteralToCharPtr &&
Ismail Pazarbasi1121de32014-01-17 21:08:52 +00003464 !getLangOpts().WritableStrings) {
3465 Diag(From->getLocStart(), getLangOpts().CPlusPlus11
3466 ? diag::ext_deprecated_string_literal_conversion
3467 : diag::warn_deprecated_string_literal_conversion)
Douglas Gregore489a7d2010-02-28 18:30:25 +00003468 << ToType.getNonReferenceType();
Ismail Pazarbasi1121de32014-01-17 21:08:52 +00003469 }
Douglas Gregore489a7d2010-02-28 18:30:25 +00003470
Douglas Gregor39c16d42008-10-24 04:54:22 +00003471 break;
Richard Smitha23ab512013-05-23 00:30:41 +00003472 }
Sebastian Redlc57d34b2010-07-20 04:20:21 +00003473
Douglas Gregor39c16d42008-10-24 04:54:22 +00003474 default:
David Blaikie83d382b2011-09-23 05:06:16 +00003475 llvm_unreachable("Improper third standard conversion");
Douglas Gregor39c16d42008-10-24 04:54:22 +00003476 }
3477
Douglas Gregor298f43d2012-04-12 20:42:30 +00003478 // If this conversion sequence involved a scalar -> atomic conversion, perform
3479 // that conversion now.
Richard Smitha23ab512013-05-23 00:30:41 +00003480 if (!ToAtomicType.isNull()) {
3481 assert(Context.hasSameType(
3482 ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()));
3483 From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00003484 VK_RValue, nullptr, CCK).get();
Richard Smitha23ab512013-05-23 00:30:41 +00003485 }
3486
George Burgess IV8d141e02015-12-14 22:00:49 +00003487 // If this conversion sequence succeeded and involved implicitly converting a
3488 // _Nullable type to a _Nonnull one, complain.
3489 if (CCK == CCK_ImplicitConversion)
3490 diagnoseNullableToNonnullConversion(ToType, InitialFromType,
3491 From->getLocStart());
3492
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00003493 return From;
Douglas Gregor39c16d42008-10-24 04:54:22 +00003494}
3495
Chandler Carruth8e172c62011-05-01 06:51:22 +00003496/// \brief Check the completeness of a type in a unary type trait.
3497///
3498/// If the particular type trait requires a complete type, tries to complete
3499/// it. If completing the type fails, a diagnostic is emitted and false
3500/// returned. If completing the type succeeds or no completion was required,
3501/// returns true.
Alp Toker95e7ff22014-01-01 05:57:51 +00003502static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
Chandler Carruth8e172c62011-05-01 06:51:22 +00003503 SourceLocation Loc,
3504 QualType ArgTy) {
3505 // C++0x [meta.unary.prop]p3:
3506 // For all of the class templates X declared in this Clause, instantiating
3507 // that template with a template argument that is a class template
3508 // specialization may result in the implicit instantiation of the template
3509 // argument if and only if the semantics of X require that the argument
3510 // must be a complete type.
3511 // We apply this rule to all the type trait expressions used to implement
3512 // these class templates. We also try to follow any GCC documented behavior
3513 // in these expressions to ensure portability of standard libraries.
3514 switch (UTT) {
Alp Toker95e7ff22014-01-01 05:57:51 +00003515 default: llvm_unreachable("not a UTT");
Chandler Carruth8e172c62011-05-01 06:51:22 +00003516 // is_complete_type somewhat obviously cannot require a complete type.
3517 case UTT_IsCompleteType:
Chandler Carrutha62d8a52011-05-01 19:18:02 +00003518 // Fall-through
Chandler Carruth8e172c62011-05-01 06:51:22 +00003519
3520 // These traits are modeled on the type predicates in C++0x
3521 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
3522 // requiring a complete type, as whether or not they return true cannot be
3523 // impacted by the completeness of the type.
3524 case UTT_IsVoid:
3525 case UTT_IsIntegral:
3526 case UTT_IsFloatingPoint:
3527 case UTT_IsArray:
3528 case UTT_IsPointer:
3529 case UTT_IsLvalueReference:
3530 case UTT_IsRvalueReference:
3531 case UTT_IsMemberFunctionPointer:
3532 case UTT_IsMemberObjectPointer:
3533 case UTT_IsEnum:
3534 case UTT_IsUnion:
3535 case UTT_IsClass:
3536 case UTT_IsFunction:
3537 case UTT_IsReference:
3538 case UTT_IsArithmetic:
3539 case UTT_IsFundamental:
3540 case UTT_IsObject:
3541 case UTT_IsScalar:
3542 case UTT_IsCompound:
3543 case UTT_IsMemberPointer:
Chandler Carrutha62d8a52011-05-01 19:18:02 +00003544 // Fall-through
Chandler Carruth8e172c62011-05-01 06:51:22 +00003545
3546 // These traits are modeled on type predicates in C++0x [meta.unary.prop]
3547 // which requires some of its traits to have the complete type. However,
3548 // the completeness of the type cannot impact these traits' semantics, and
3549 // so they don't require it. This matches the comments on these traits in
3550 // Table 49.
3551 case UTT_IsConst:
3552 case UTT_IsVolatile:
3553 case UTT_IsSigned:
3554 case UTT_IsUnsigned:
David Majnemer213bea32015-11-16 06:58:51 +00003555
3556 // This type trait always returns false, checking the type is moot.
3557 case UTT_IsInterfaceClass:
Chandler Carruth8e172c62011-05-01 06:51:22 +00003558 return true;
3559
David Majnemer213bea32015-11-16 06:58:51 +00003560 // C++14 [meta.unary.prop]:
3561 // If T is a non-union class type, T shall be a complete type.
3562 case UTT_IsEmpty:
3563 case UTT_IsPolymorphic:
3564 case UTT_IsAbstract:
3565 if (const auto *RD = ArgTy->getAsCXXRecordDecl())
3566 if (!RD->isUnion())
3567 return !S.RequireCompleteType(
3568 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
3569 return true;
3570
3571 // C++14 [meta.unary.prop]:
3572 // If T is a class type, T shall be a complete type.
3573 case UTT_IsFinal:
3574 case UTT_IsSealed:
3575 if (ArgTy->getAsCXXRecordDecl())
3576 return !S.RequireCompleteType(
3577 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
3578 return true;
3579
3580 // C++0x [meta.unary.prop] Table 49 requires the following traits to be
3581 // applied to a complete type.
Chandler Carruth8e172c62011-05-01 06:51:22 +00003582 case UTT_IsTrivial:
Alexis Huntd9a5cc12011-05-13 00:31:07 +00003583 case UTT_IsTriviallyCopyable:
Chandler Carruth8e172c62011-05-01 06:51:22 +00003584 case UTT_IsStandardLayout:
3585 case UTT_IsPOD:
3586 case UTT_IsLiteral:
David Majnemer213bea32015-11-16 06:58:51 +00003587
Alp Toker73287bf2014-01-20 00:24:09 +00003588 case UTT_IsDestructible:
3589 case UTT_IsNothrowDestructible:
Chandler Carrutha62d8a52011-05-01 19:18:02 +00003590 // Fall-through
Chandler Carruth8e172c62011-05-01 06:51:22 +00003591
Chandler Carrutha62d8a52011-05-01 19:18:02 +00003592 // These trait expressions are designed to help implement predicates in
Chandler Carruth8e172c62011-05-01 06:51:22 +00003593 // [meta.unary.prop] despite not being named the same. They are specified
3594 // by both GCC and the Embarcadero C++ compiler, and require the complete
3595 // type due to the overarching C++0x type predicates being implemented
3596 // requiring the complete type.
3597 case UTT_HasNothrowAssign:
Joao Matosc9523d42013-03-27 01:34:16 +00003598 case UTT_HasNothrowMoveAssign:
Chandler Carruth8e172c62011-05-01 06:51:22 +00003599 case UTT_HasNothrowConstructor:
3600 case UTT_HasNothrowCopy:
3601 case UTT_HasTrivialAssign:
Joao Matosc9523d42013-03-27 01:34:16 +00003602 case UTT_HasTrivialMoveAssign:
Alexis Huntf479f1b2011-05-09 18:22:59 +00003603 case UTT_HasTrivialDefaultConstructor:
Joao Matosc9523d42013-03-27 01:34:16 +00003604 case UTT_HasTrivialMoveConstructor:
Chandler Carruth8e172c62011-05-01 06:51:22 +00003605 case UTT_HasTrivialCopy:
3606 case UTT_HasTrivialDestructor:
3607 case UTT_HasVirtualDestructor:
3608 // Arrays of unknown bound are expressly allowed.
3609 QualType ElTy = ArgTy;
3610 if (ArgTy->isIncompleteArrayType())
3611 ElTy = S.Context.getAsArrayType(ArgTy)->getElementType();
3612
3613 // The void type is expressly allowed.
3614 if (ElTy->isVoidType())
3615 return true;
3616
3617 return !S.RequireCompleteType(
3618 Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
John Wiegleyd3522222011-04-28 02:06:46 +00003619 }
Chandler Carruth8e172c62011-05-01 06:51:22 +00003620}
3621
Joao Matosc9523d42013-03-27 01:34:16 +00003622static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op,
3623 Sema &Self, SourceLocation KeyLoc, ASTContext &C,
3624 bool (CXXRecordDecl::*HasTrivial)() const,
3625 bool (CXXRecordDecl::*HasNonTrivial)() const,
3626 bool (CXXMethodDecl::*IsDesiredOp)() const)
3627{
3628 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
3629 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
3630 return true;
3631
3632 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(Op);
3633 DeclarationNameInfo NameInfo(Name, KeyLoc);
3634 LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName);
3635 if (Self.LookupQualifiedName(Res, RD)) {
3636 bool FoundOperator = false;
3637 Res.suppressDiagnostics();
3638 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
3639 Op != OpEnd; ++Op) {
3640 if (isa<FunctionTemplateDecl>(*Op))
3641 continue;
3642
3643 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3644 if((Operator->*IsDesiredOp)()) {
3645 FoundOperator = true;
3646 const FunctionProtoType *CPT =
3647 Operator->getType()->getAs<FunctionProtoType>();
3648 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
Alp Toker73287bf2014-01-20 00:24:09 +00003649 if (!CPT || !CPT->isNothrow(C))
Joao Matosc9523d42013-03-27 01:34:16 +00003650 return false;
3651 }
3652 }
3653 return FoundOperator;
3654 }
3655 return false;
3656}
3657
Alp Toker95e7ff22014-01-01 05:57:51 +00003658static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
Chandler Carruth8e172c62011-05-01 06:51:22 +00003659 SourceLocation KeyLoc, QualType T) {
Chandler Carruth0d1a54f2011-05-01 08:41:10 +00003660 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegleyd3522222011-04-28 02:06:46 +00003661
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003662 ASTContext &C = Self.Context;
3663 switch(UTT) {
Alp Toker95e7ff22014-01-01 05:57:51 +00003664 default: llvm_unreachable("not a UTT");
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003665 // Type trait expressions corresponding to the primary type category
3666 // predicates in C++0x [meta.unary.cat].
3667 case UTT_IsVoid:
3668 return T->isVoidType();
3669 case UTT_IsIntegral:
3670 return T->isIntegralType(C);
3671 case UTT_IsFloatingPoint:
3672 return T->isFloatingType();
3673 case UTT_IsArray:
3674 return T->isArrayType();
3675 case UTT_IsPointer:
3676 return T->isPointerType();
3677 case UTT_IsLvalueReference:
3678 return T->isLValueReferenceType();
3679 case UTT_IsRvalueReference:
3680 return T->isRValueReferenceType();
3681 case UTT_IsMemberFunctionPointer:
3682 return T->isMemberFunctionPointerType();
3683 case UTT_IsMemberObjectPointer:
3684 return T->isMemberDataPointerType();
3685 case UTT_IsEnum:
3686 return T->isEnumeralType();
Chandler Carruth100f3a92011-05-01 06:11:03 +00003687 case UTT_IsUnion:
Chandler Carruthaf858862011-05-01 09:29:58 +00003688 return T->isUnionType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003689 case UTT_IsClass:
Joao Matosdc86f942012-08-31 18:45:21 +00003690 return T->isClassType() || T->isStructureType() || T->isInterfaceType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003691 case UTT_IsFunction:
3692 return T->isFunctionType();
3693
3694 // Type trait expressions which correspond to the convenient composition
3695 // predicates in C++0x [meta.unary.comp].
3696 case UTT_IsReference:
3697 return T->isReferenceType();
3698 case UTT_IsArithmetic:
Chandler Carruthaf858862011-05-01 09:29:58 +00003699 return T->isArithmeticType() && !T->isEnumeralType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003700 case UTT_IsFundamental:
Chandler Carruthaf858862011-05-01 09:29:58 +00003701 return T->isFundamentalType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003702 case UTT_IsObject:
Chandler Carruthaf858862011-05-01 09:29:58 +00003703 return T->isObjectType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003704 case UTT_IsScalar:
John McCall31168b02011-06-15 23:02:42 +00003705 // Note: semantic analysis depends on Objective-C lifetime types to be
3706 // considered scalar types. However, such types do not actually behave
3707 // like scalar types at run time (since they may require retain/release
3708 // operations), so we report them as non-scalar.
3709 if (T->isObjCLifetimeType()) {
3710 switch (T.getObjCLifetime()) {
3711 case Qualifiers::OCL_None:
3712 case Qualifiers::OCL_ExplicitNone:
3713 return true;
3714
3715 case Qualifiers::OCL_Strong:
3716 case Qualifiers::OCL_Weak:
3717 case Qualifiers::OCL_Autoreleasing:
3718 return false;
3719 }
3720 }
3721
Chandler Carruth7ba7bd32011-05-01 09:29:55 +00003722 return T->isScalarType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003723 case UTT_IsCompound:
Chandler Carruthaf858862011-05-01 09:29:58 +00003724 return T->isCompoundType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003725 case UTT_IsMemberPointer:
3726 return T->isMemberPointerType();
3727
3728 // Type trait expressions which correspond to the type property predicates
3729 // in C++0x [meta.unary.prop].
3730 case UTT_IsConst:
3731 return T.isConstQualified();
3732 case UTT_IsVolatile:
3733 return T.isVolatileQualified();
3734 case UTT_IsTrivial:
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003735 return T.isTrivialType(C);
Alexis Huntd9a5cc12011-05-13 00:31:07 +00003736 case UTT_IsTriviallyCopyable:
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003737 return T.isTriviallyCopyableType(C);
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003738 case UTT_IsStandardLayout:
3739 return T->isStandardLayoutType();
3740 case UTT_IsPOD:
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003741 return T.isPODType(C);
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003742 case UTT_IsLiteral:
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003743 return T->isLiteralType(C);
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003744 case UTT_IsEmpty:
3745 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3746 return !RD->isUnion() && RD->isEmpty();
3747 return false;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003748 case UTT_IsPolymorphic:
Chandler Carruth100f3a92011-05-01 06:11:03 +00003749 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
David Majnemer213bea32015-11-16 06:58:51 +00003750 return !RD->isUnion() && RD->isPolymorphic();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003751 return false;
3752 case UTT_IsAbstract:
Chandler Carruth100f3a92011-05-01 06:11:03 +00003753 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
David Majnemer213bea32015-11-16 06:58:51 +00003754 return !RD->isUnion() && RD->isAbstract();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003755 return false;
David Majnemer213bea32015-11-16 06:58:51 +00003756 // __is_interface_class only returns true when CL is invoked in /CLR mode and
3757 // even then only when it is used with the 'interface struct ...' syntax
3758 // Clang doesn't support /CLR which makes this type trait moot.
John McCallbf4a7d72012-09-25 07:32:49 +00003759 case UTT_IsInterfaceClass:
John McCallbf4a7d72012-09-25 07:32:49 +00003760 return false;
Douglas Gregordca70af2011-12-03 18:14:24 +00003761 case UTT_IsFinal:
David Majnemera5433082013-10-18 00:33:31 +00003762 case UTT_IsSealed:
3763 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
David Majnemer213bea32015-11-16 06:58:51 +00003764 return RD->hasAttr<FinalAttr>();
David Majnemera5433082013-10-18 00:33:31 +00003765 return false;
John Wiegley65497cc2011-04-27 23:09:49 +00003766 case UTT_IsSigned:
3767 return T->isSignedIntegerType();
John Wiegley65497cc2011-04-27 23:09:49 +00003768 case UTT_IsUnsigned:
3769 return T->isUnsignedIntegerType();
Chandler Carruthd2479ea2011-05-01 06:11:07 +00003770
3771 // Type trait expressions which query classes regarding their construction,
3772 // destruction, and copying. Rather than being based directly on the
3773 // related type predicates in the standard, they are specified by both
3774 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
3775 // specifications.
3776 //
3777 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
3778 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
Richard Smith92f241f2012-12-08 02:53:02 +00003779 //
3780 // Note that these builtins do not behave as documented in g++: if a class
3781 // has both a trivial and a non-trivial special member of a particular kind,
3782 // they return false! For now, we emulate this behavior.
3783 // FIXME: This appears to be a g++ bug: more complex cases reveal that it
3784 // does not correctly compute triviality in the presence of multiple special
3785 // members of the same kind. Revisit this once the g++ bug is fixed.
Alexis Huntf479f1b2011-05-09 18:22:59 +00003786 case UTT_HasTrivialDefaultConstructor:
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003787 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3788 // If __is_pod (type) is true then the trait is true, else if type is
3789 // a cv class or union type (or array thereof) with a trivial default
3790 // constructor ([class.ctor]) then the trait is true, else it is false.
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003791 if (T.isPODType(C))
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003792 return true;
Richard Smith92f241f2012-12-08 02:53:02 +00003793 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3794 return RD->hasTrivialDefaultConstructor() &&
3795 !RD->hasNonTrivialDefaultConstructor();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003796 return false;
Joao Matosc9523d42013-03-27 01:34:16 +00003797 case UTT_HasTrivialMoveConstructor:
3798 // This trait is implemented by MSVC 2012 and needed to parse the
3799 // standard library headers. Specifically this is used as the logic
3800 // behind std::is_trivially_move_constructible (20.9.4.3).
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003801 if (T.isPODType(C))
Joao Matosc9523d42013-03-27 01:34:16 +00003802 return true;
3803 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3804 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
3805 return false;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003806 case UTT_HasTrivialCopy:
3807 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3808 // If __is_pod (type) is true or type is a reference type then
3809 // the trait is true, else if type is a cv class or union type
3810 // with a trivial copy constructor ([class.copy]) then the trait
3811 // is true, else it is false.
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003812 if (T.isPODType(C) || T->isReferenceType())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003813 return true;
Richard Smith92f241f2012-12-08 02:53:02 +00003814 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3815 return RD->hasTrivialCopyConstructor() &&
3816 !RD->hasNonTrivialCopyConstructor();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003817 return false;
Joao Matosc9523d42013-03-27 01:34:16 +00003818 case UTT_HasTrivialMoveAssign:
3819 // This trait is implemented by MSVC 2012 and needed to parse the
3820 // standard library headers. Specifically it is used as the logic
3821 // behind std::is_trivially_move_assignable (20.9.4.3)
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003822 if (T.isPODType(C))
Joao Matosc9523d42013-03-27 01:34:16 +00003823 return true;
3824 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3825 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
3826 return false;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003827 case UTT_HasTrivialAssign:
3828 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3829 // If type is const qualified or is a reference type then the
3830 // trait is false. Otherwise if __is_pod (type) is true then the
3831 // trait is true, else if type is a cv class or union type with
3832 // a trivial copy assignment ([class.copy]) then the trait is
3833 // true, else it is false.
3834 // Note: the const and reference restrictions are interesting,
3835 // given that const and reference members don't prevent a class
3836 // from having a trivial copy assignment operator (but do cause
3837 // errors if the copy assignment operator is actually used, q.v.
3838 // [class.copy]p12).
3839
Richard Smith92f241f2012-12-08 02:53:02 +00003840 if (T.isConstQualified())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003841 return false;
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003842 if (T.isPODType(C))
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003843 return true;
Richard Smith92f241f2012-12-08 02:53:02 +00003844 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3845 return RD->hasTrivialCopyAssignment() &&
3846 !RD->hasNonTrivialCopyAssignment();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003847 return false;
Alp Toker73287bf2014-01-20 00:24:09 +00003848 case UTT_IsDestructible:
3849 case UTT_IsNothrowDestructible:
David Majnemerac73de92015-08-11 03:03:28 +00003850 // C++14 [meta.unary.prop]:
3851 // For reference types, is_destructible<T>::value is true.
3852 if (T->isReferenceType())
3853 return true;
3854
3855 // Objective-C++ ARC: autorelease types don't require destruction.
3856 if (T->isObjCLifetimeType() &&
3857 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
3858 return true;
3859
3860 // C++14 [meta.unary.prop]:
3861 // For incomplete types and function types, is_destructible<T>::value is
3862 // false.
3863 if (T->isIncompleteType() || T->isFunctionType())
3864 return false;
3865
3866 // C++14 [meta.unary.prop]:
3867 // For object types and given U equal to remove_all_extents_t<T>, if the
3868 // expression std::declval<U&>().~U() is well-formed when treated as an
3869 // unevaluated operand (Clause 5), then is_destructible<T>::value is true
3870 if (auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
3871 CXXDestructorDecl *Destructor = Self.LookupDestructor(RD);
3872 if (!Destructor)
3873 return false;
3874 // C++14 [dcl.fct.def.delete]p2:
3875 // A program that refers to a deleted function implicitly or
3876 // explicitly, other than to declare it, is ill-formed.
3877 if (Destructor->isDeleted())
3878 return false;
3879 if (C.getLangOpts().AccessControl && Destructor->getAccess() != AS_public)
3880 return false;
3881 if (UTT == UTT_IsNothrowDestructible) {
3882 const FunctionProtoType *CPT =
3883 Destructor->getType()->getAs<FunctionProtoType>();
3884 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3885 if (!CPT || !CPT->isNothrow(C))
3886 return false;
3887 }
3888 }
3889 return true;
3890
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003891 case UTT_HasTrivialDestructor:
Alp Toker73287bf2014-01-20 00:24:09 +00003892 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003893 // If __is_pod (type) is true or type is a reference type
3894 // then the trait is true, else if type is a cv class or union
3895 // type (or array thereof) with a trivial destructor
3896 // ([class.dtor]) then the trait is true, else it is
3897 // false.
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003898 if (T.isPODType(C) || T->isReferenceType())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003899 return true;
John McCall31168b02011-06-15 23:02:42 +00003900
3901 // Objective-C++ ARC: autorelease types don't require destruction.
3902 if (T->isObjCLifetimeType() &&
3903 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
3904 return true;
3905
Richard Smith92f241f2012-12-08 02:53:02 +00003906 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3907 return RD->hasTrivialDestructor();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003908 return false;
3909 // TODO: Propagate nothrowness for implicitly declared special members.
3910 case UTT_HasNothrowAssign:
3911 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3912 // If type is const qualified or is a reference type then the
3913 // trait is false. Otherwise if __has_trivial_assign (type)
3914 // is true then the trait is true, else if type is a cv class
3915 // or union type with copy assignment operators that are known
3916 // not to throw an exception then the trait is true, else it is
3917 // false.
3918 if (C.getBaseElementType(T).isConstQualified())
3919 return false;
3920 if (T->isReferenceType())
3921 return false;
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003922 if (T.isPODType(C) || T->isObjCLifetimeType())
Joao Matosc9523d42013-03-27 01:34:16 +00003923 return true;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003924
Joao Matosc9523d42013-03-27 01:34:16 +00003925 if (const RecordType *RT = T->getAs<RecordType>())
3926 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3927 &CXXRecordDecl::hasTrivialCopyAssignment,
3928 &CXXRecordDecl::hasNonTrivialCopyAssignment,
3929 &CXXMethodDecl::isCopyAssignmentOperator);
3930 return false;
3931 case UTT_HasNothrowMoveAssign:
3932 // This trait is implemented by MSVC 2012 and needed to parse the
3933 // standard library headers. Specifically this is used as the logic
3934 // behind std::is_nothrow_move_assignable (20.9.4.3).
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003935 if (T.isPODType(C))
Joao Matosc9523d42013-03-27 01:34:16 +00003936 return true;
3937
3938 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
3939 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3940 &CXXRecordDecl::hasTrivialMoveAssignment,
3941 &CXXRecordDecl::hasNonTrivialMoveAssignment,
3942 &CXXMethodDecl::isMoveAssignmentOperator);
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003943 return false;
3944 case UTT_HasNothrowCopy:
3945 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3946 // If __has_trivial_copy (type) is true then the trait is true, else
3947 // if type is a cv class or union type with copy constructors that are
3948 // known not to throw an exception then the trait is true, else it is
3949 // false.
John McCall31168b02011-06-15 23:02:42 +00003950 if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003951 return true;
Richard Smith92f241f2012-12-08 02:53:02 +00003952 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
3953 if (RD->hasTrivialCopyConstructor() &&
3954 !RD->hasNonTrivialCopyConstructor())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003955 return true;
3956
3957 bool FoundConstructor = false;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003958 unsigned FoundTQs;
Aaron Ballmane4de1a512015-07-21 22:33:52 +00003959 for (const auto *ND : Self.LookupConstructors(RD)) {
Sebastian Redl5c649bc2010-09-13 22:18:28 +00003960 // A template constructor is never a copy constructor.
3961 // FIXME: However, it may actually be selected at the actual overload
3962 // resolution point.
Aaron Ballmane4de1a512015-07-21 22:33:52 +00003963 if (isa<FunctionTemplateDecl>(ND))
Sebastian Redl5c649bc2010-09-13 22:18:28 +00003964 continue;
Aaron Ballmane4de1a512015-07-21 22:33:52 +00003965 const CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(ND);
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003966 if (Constructor->isCopyConstructor(FoundTQs)) {
3967 FoundConstructor = true;
3968 const FunctionProtoType *CPT
3969 = Constructor->getType()->getAs<FunctionProtoType>();
Richard Smithf623c962012-04-17 00:58:00 +00003970 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3971 if (!CPT)
3972 return false;
Alp Toker73287bf2014-01-20 00:24:09 +00003973 // TODO: check whether evaluating default arguments can throw.
Sebastian Redlc15c3262010-09-13 22:02:47 +00003974 // For now, we'll be conservative and assume that they can throw.
Aaron Ballmand4a392c2015-07-21 21:07:11 +00003975 if (!CPT->isNothrow(C) || CPT->getNumParams() > 1)
Richard Smith938f40b2011-06-11 17:19:42 +00003976 return false;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003977 }
3978 }
3979
Richard Smith938f40b2011-06-11 17:19:42 +00003980 return FoundConstructor;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003981 }
3982 return false;
3983 case UTT_HasNothrowConstructor:
Alp Tokerb4bca412014-01-20 00:23:47 +00003984 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003985 // If __has_trivial_constructor (type) is true then the trait is
3986 // true, else if type is a cv class or union type (or array
3987 // thereof) with a default constructor that is known not to
3988 // throw an exception then the trait is true, else it is false.
John McCall31168b02011-06-15 23:02:42 +00003989 if (T.isPODType(C) || T->isObjCLifetimeType())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003990 return true;
Richard Smith92f241f2012-12-08 02:53:02 +00003991 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
3992 if (RD->hasTrivialDefaultConstructor() &&
3993 !RD->hasNonTrivialDefaultConstructor())
Sebastian Redl8eb06f12010-09-13 20:56:31 +00003994 return true;
3995
Alp Tokerb4bca412014-01-20 00:23:47 +00003996 bool FoundConstructor = false;
Aaron Ballmane4de1a512015-07-21 22:33:52 +00003997 for (const auto *ND : Self.LookupConstructors(RD)) {
Sebastian Redl5c649bc2010-09-13 22:18:28 +00003998 // FIXME: In C++0x, a constructor template can be a default constructor.
Aaron Ballmane4de1a512015-07-21 22:33:52 +00003999 if (isa<FunctionTemplateDecl>(ND))
Sebastian Redl5c649bc2010-09-13 22:18:28 +00004000 continue;
Aaron Ballmane4de1a512015-07-21 22:33:52 +00004001 const CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(ND);
Sebastian Redlc15c3262010-09-13 22:02:47 +00004002 if (Constructor->isDefaultConstructor()) {
Alp Tokerb4bca412014-01-20 00:23:47 +00004003 FoundConstructor = true;
Sebastian Redlc15c3262010-09-13 22:02:47 +00004004 const FunctionProtoType *CPT
4005 = Constructor->getType()->getAs<FunctionProtoType>();
Richard Smithf623c962012-04-17 00:58:00 +00004006 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4007 if (!CPT)
4008 return false;
Alp Tokerb4bca412014-01-20 00:23:47 +00004009 // FIXME: check whether evaluating default arguments can throw.
Sebastian Redlc15c3262010-09-13 22:02:47 +00004010 // For now, we'll be conservative and assume that they can throw.
Aaron Ballmand4a392c2015-07-21 21:07:11 +00004011 if (!CPT->isNothrow(C) || CPT->getNumParams() > 0)
Alp Tokerb4bca412014-01-20 00:23:47 +00004012 return false;
Sebastian Redlc15c3262010-09-13 22:02:47 +00004013 }
Sebastian Redl8eb06f12010-09-13 20:56:31 +00004014 }
Alp Tokerb4bca412014-01-20 00:23:47 +00004015 return FoundConstructor;
Sebastian Redl8eb06f12010-09-13 20:56:31 +00004016 }
4017 return false;
4018 case UTT_HasVirtualDestructor:
4019 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4020 // If type is a class type with a virtual destructor ([class.dtor])
4021 // then the trait is true, else it is false.
Richard Smith92f241f2012-12-08 02:53:02 +00004022 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
Sebastian Redl058fc822010-09-14 23:40:14 +00004023 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
Sebastian Redl8eb06f12010-09-13 20:56:31 +00004024 return Destructor->isVirtual();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00004025 return false;
Chandler Carruthd2479ea2011-05-01 06:11:07 +00004026
4027 // These type trait expressions are modeled on the specifications for the
4028 // Embarcadero C++0x type trait functions:
4029 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4030 case UTT_IsCompleteType:
4031 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
4032 // Returns True if and only if T is a complete type at the point of the
4033 // function call.
4034 return !T->isIncompleteType();
Sebastian Redl8eb06f12010-09-13 20:56:31 +00004035 }
Sebastian Redlbaad4e72009-01-05 20:52:13 +00004036}
Sebastian Redl5822f082009-02-07 20:10:22 +00004037
Douglas Gregor6bd56ca2012-06-29 00:49:17 +00004038/// \brief Determine whether T has a non-trivial Objective-C lifetime in
4039/// ARC mode.
4040static bool hasNontrivialObjCLifetime(QualType T) {
4041 switch (T.getObjCLifetime()) {
4042 case Qualifiers::OCL_ExplicitNone:
4043 return false;
4044
4045 case Qualifiers::OCL_Strong:
4046 case Qualifiers::OCL_Weak:
4047 case Qualifiers::OCL_Autoreleasing:
4048 return true;
4049
4050 case Qualifiers::OCL_None:
4051 return T->isObjCLifetimeType();
4052 }
4053
4054 llvm_unreachable("Unknown ObjC lifetime qualifier");
4055}
4056
Alp Tokercbb90342013-12-13 20:49:58 +00004057static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4058 QualType RhsT, SourceLocation KeyLoc);
4059
Douglas Gregor29c42f22012-02-24 07:38:34 +00004060static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
4061 ArrayRef<TypeSourceInfo *> Args,
4062 SourceLocation RParenLoc) {
Alp Toker95e7ff22014-01-01 05:57:51 +00004063 if (Kind <= UTT_Last)
4064 return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
4065
Alp Tokercbb90342013-12-13 20:49:58 +00004066 if (Kind <= BTT_Last)
4067 return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
4068 Args[1]->getType(), RParenLoc);
4069
Douglas Gregor29c42f22012-02-24 07:38:34 +00004070 switch (Kind) {
Alp Toker73287bf2014-01-20 00:24:09 +00004071 case clang::TT_IsConstructible:
4072 case clang::TT_IsNothrowConstructible:
Douglas Gregor29c42f22012-02-24 07:38:34 +00004073 case clang::TT_IsTriviallyConstructible: {
4074 // C++11 [meta.unary.prop]:
Dmitri Gribenko85e87642012-02-24 20:03:35 +00004075 // is_trivially_constructible is defined as:
Douglas Gregor29c42f22012-02-24 07:38:34 +00004076 //
Dmitri Gribenko85e87642012-02-24 20:03:35 +00004077 // is_constructible<T, Args...>::value is true and the variable
Richard Smith8b86f2d2013-11-04 01:48:18 +00004078 // definition for is_constructible, as defined below, is known to call
4079 // no operation that is not trivial.
Douglas Gregor29c42f22012-02-24 07:38:34 +00004080 //
4081 // The predicate condition for a template specialization
4082 // is_constructible<T, Args...> shall be satisfied if and only if the
4083 // following variable definition would be well-formed for some invented
4084 // variable t:
4085 //
4086 // T t(create<Args>()...);
Alp Toker40f9b1c2013-12-12 21:23:03 +00004087 assert(!Args.empty());
Eli Friedman9ea1e162013-09-11 02:53:02 +00004088
4089 // Precondition: T and all types in the parameter pack Args shall be
4090 // complete types, (possibly cv-qualified) void, or arrays of
4091 // unknown bound.
Aaron Ballman2bf2cad2015-07-21 21:18:29 +00004092 for (const auto *TSI : Args) {
4093 QualType ArgTy = TSI->getType();
Eli Friedman9ea1e162013-09-11 02:53:02 +00004094 if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
Douglas Gregor29c42f22012-02-24 07:38:34 +00004095 continue;
Eli Friedman9ea1e162013-09-11 02:53:02 +00004096
4097 if (S.RequireCompleteType(KWLoc, ArgTy,
Douglas Gregor29c42f22012-02-24 07:38:34 +00004098 diag::err_incomplete_type_used_in_type_trait_expr))
4099 return false;
4100 }
Eli Friedman9ea1e162013-09-11 02:53:02 +00004101
David Majnemer9658ecc2015-11-13 05:32:43 +00004102 // Make sure the first argument is not incomplete nor a function type.
4103 QualType T = Args[0]->getType();
4104 if (T->isIncompleteType() || T->isFunctionType())
Douglas Gregor29c42f22012-02-24 07:38:34 +00004105 return false;
Eli Friedman9ea1e162013-09-11 02:53:02 +00004106
Nikola Smiljanic1b4b6ba2014-04-15 11:30:15 +00004107 // Make sure the first argument is not an abstract type.
David Majnemer9658ecc2015-11-13 05:32:43 +00004108 CXXRecordDecl *RD = T->getAsCXXRecordDecl();
Nikola Smiljanic1b4b6ba2014-04-15 11:30:15 +00004109 if (RD && RD->isAbstract())
4110 return false;
4111
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004112 SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
4113 SmallVector<Expr *, 2> ArgExprs;
Douglas Gregor29c42f22012-02-24 07:38:34 +00004114 ArgExprs.reserve(Args.size() - 1);
4115 for (unsigned I = 1, N = Args.size(); I != N; ++I) {
David Majnemer9658ecc2015-11-13 05:32:43 +00004116 QualType ArgTy = Args[I]->getType();
4117 if (ArgTy->isObjectType() || ArgTy->isFunctionType())
4118 ArgTy = S.Context.getRValueReferenceType(ArgTy);
Douglas Gregor29c42f22012-02-24 07:38:34 +00004119 OpaqueArgExprs.push_back(
David Majnemer9658ecc2015-11-13 05:32:43 +00004120 OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
4121 ArgTy.getNonLValueExprType(S.Context),
4122 Expr::getValueKindForType(ArgTy)));
Douglas Gregor29c42f22012-02-24 07:38:34 +00004123 }
Richard Smitha507bfc2014-07-23 20:07:08 +00004124 for (Expr &E : OpaqueArgExprs)
4125 ArgExprs.push_back(&E);
4126
Douglas Gregor29c42f22012-02-24 07:38:34 +00004127 // Perform the initialization in an unevaluated context within a SFINAE
4128 // trap at translation unit scope.
4129 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
4130 Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
4131 Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl());
4132 InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0]));
4133 InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc,
4134 RParenLoc));
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004135 InitializationSequence Init(S, To, InitKind, ArgExprs);
Douglas Gregor29c42f22012-02-24 07:38:34 +00004136 if (Init.Failed())
4137 return false;
Alp Toker73287bf2014-01-20 00:24:09 +00004138
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004139 ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
Douglas Gregor29c42f22012-02-24 07:38:34 +00004140 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4141 return false;
Douglas Gregor6bd56ca2012-06-29 00:49:17 +00004142
Alp Toker73287bf2014-01-20 00:24:09 +00004143 if (Kind == clang::TT_IsConstructible)
4144 return true;
Douglas Gregor6bd56ca2012-06-29 00:49:17 +00004145
Alp Toker73287bf2014-01-20 00:24:09 +00004146 if (Kind == clang::TT_IsNothrowConstructible)
4147 return S.canThrow(Result.get()) == CT_Cannot;
4148
4149 if (Kind == clang::TT_IsTriviallyConstructible) {
4150 // Under Objective-C ARC, if the destination has non-trivial Objective-C
4151 // lifetime, this is a non-trivial construction.
4152 if (S.getLangOpts().ObjCAutoRefCount &&
David Majnemer9658ecc2015-11-13 05:32:43 +00004153 hasNontrivialObjCLifetime(T.getNonReferenceType()))
Alp Toker73287bf2014-01-20 00:24:09 +00004154 return false;
4155
4156 // The initialization succeeded; now make sure there are no non-trivial
4157 // calls.
4158 return !Result.get()->hasNonTrivialCall(S.Context);
4159 }
4160
4161 llvm_unreachable("unhandled type trait");
4162 return false;
Douglas Gregor29c42f22012-02-24 07:38:34 +00004163 }
Alp Tokercbb90342013-12-13 20:49:58 +00004164 default: llvm_unreachable("not a TT");
Douglas Gregor29c42f22012-02-24 07:38:34 +00004165 }
4166
4167 return false;
4168}
4169
4170ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
4171 ArrayRef<TypeSourceInfo *> Args,
4172 SourceLocation RParenLoc) {
Alp Toker5294e6e2013-12-25 01:47:02 +00004173 QualType ResultType = Context.getLogicalOperationType();
Alp Tokercbb90342013-12-13 20:49:58 +00004174
Alp Toker95e7ff22014-01-01 05:57:51 +00004175 if (Kind <= UTT_Last && !CheckUnaryTypeTraitTypeCompleteness(
4176 *this, Kind, KWLoc, Args[0]->getType()))
4177 return ExprError();
4178
Douglas Gregor29c42f22012-02-24 07:38:34 +00004179 bool Dependent = false;
4180 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4181 if (Args[I]->getType()->isDependentType()) {
4182 Dependent = true;
4183 break;
4184 }
4185 }
Alp Tokercbb90342013-12-13 20:49:58 +00004186
4187 bool Result = false;
Douglas Gregor29c42f22012-02-24 07:38:34 +00004188 if (!Dependent)
Alp Tokercbb90342013-12-13 20:49:58 +00004189 Result = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc);
4190
4191 return TypeTraitExpr::Create(Context, ResultType, KWLoc, Kind, Args,
4192 RParenLoc, Result);
Douglas Gregor29c42f22012-02-24 07:38:34 +00004193}
4194
Alp Toker88f64e62013-12-13 21:19:30 +00004195ExprResult Sema::ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
4196 ArrayRef<ParsedType> Args,
Douglas Gregor29c42f22012-02-24 07:38:34 +00004197 SourceLocation RParenLoc) {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004198 SmallVector<TypeSourceInfo *, 4> ConvertedArgs;
Douglas Gregor29c42f22012-02-24 07:38:34 +00004199 ConvertedArgs.reserve(Args.size());
4200
4201 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
4202 TypeSourceInfo *TInfo;
4203 QualType T = GetTypeFromParser(Args[I], &TInfo);
4204 if (!TInfo)
4205 TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc);
4206
4207 ConvertedArgs.push_back(TInfo);
4208 }
Alp Tokercbb90342013-12-13 20:49:58 +00004209
Douglas Gregor29c42f22012-02-24 07:38:34 +00004210 return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc);
4211}
4212
Alp Tokercbb90342013-12-13 20:49:58 +00004213static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4214 QualType RhsT, SourceLocation KeyLoc) {
Chandler Carruth0d1a54f2011-05-01 08:41:10 +00004215 assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
4216 "Cannot evaluate traits of dependent types");
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00004217
4218 switch(BTT) {
John McCall388ef532011-01-28 22:02:36 +00004219 case BTT_IsBaseOf: {
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00004220 // C++0x [meta.rel]p2
John McCall388ef532011-01-28 22:02:36 +00004221 // Base is a base class of Derived without regard to cv-qualifiers or
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00004222 // Base and Derived are not unions and name the same class type without
4223 // regard to cv-qualifiers.
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00004224
John McCall388ef532011-01-28 22:02:36 +00004225 const RecordType *lhsRecord = LhsT->getAs<RecordType>();
4226 if (!lhsRecord) return false;
4227
4228 const RecordType *rhsRecord = RhsT->getAs<RecordType>();
4229 if (!rhsRecord) return false;
4230
4231 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
4232 == (lhsRecord == rhsRecord));
4233
4234 if (lhsRecord == rhsRecord)
4235 return !lhsRecord->getDecl()->isUnion();
4236
4237 // C++0x [meta.rel]p2:
4238 // If Base and Derived are class types and are different types
4239 // (ignoring possible cv-qualifiers) then Derived shall be a
4240 // complete type.
4241 if (Self.RequireCompleteType(KeyLoc, RhsT,
4242 diag::err_incomplete_type_used_in_type_trait_expr))
4243 return false;
4244
4245 return cast<CXXRecordDecl>(rhsRecord->getDecl())
4246 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
4247 }
John Wiegley65497cc2011-04-27 23:09:49 +00004248 case BTT_IsSame:
4249 return Self.Context.hasSameType(LhsT, RhsT);
Francois Pichet34b21132010-12-08 22:35:30 +00004250 case BTT_TypeCompatible:
4251 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(),
4252 RhsT.getUnqualifiedType());
John Wiegley65497cc2011-04-27 23:09:49 +00004253 case BTT_IsConvertible:
Douglas Gregor8006e762011-01-27 20:28:01 +00004254 case BTT_IsConvertibleTo: {
4255 // C++0x [meta.rel]p4:
4256 // Given the following function prototype:
4257 //
4258 // template <class T>
4259 // typename add_rvalue_reference<T>::type create();
4260 //
4261 // the predicate condition for a template specialization
4262 // is_convertible<From, To> shall be satisfied if and only if
4263 // the return expression in the following code would be
4264 // well-formed, including any implicit conversions to the return
4265 // type of the function:
4266 //
4267 // To test() {
4268 // return create<From>();
4269 // }
4270 //
4271 // Access checking is performed as if in a context unrelated to To and
4272 // From. Only the validity of the immediate context of the expression
4273 // of the return-statement (including conversions to the return type)
4274 // is considered.
4275 //
4276 // We model the initialization as a copy-initialization of a temporary
4277 // of the appropriate type, which for this expression is identical to the
4278 // return statement (since NRVO doesn't apply).
Eli Friedman1d4c3cf2012-08-14 02:06:07 +00004279
4280 // Functions aren't allowed to return function or array types.
4281 if (RhsT->isFunctionType() || RhsT->isArrayType())
4282 return false;
4283
4284 // A return statement in a void function must have void type.
4285 if (RhsT->isVoidType())
4286 return LhsT->isVoidType();
4287
4288 // A function definition requires a complete, non-abstract return type.
Richard Smithdb0ac552015-12-18 22:40:25 +00004289 if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
Eli Friedman1d4c3cf2012-08-14 02:06:07 +00004290 return false;
4291
4292 // Compute the result of add_rvalue_reference.
Douglas Gregor8006e762011-01-27 20:28:01 +00004293 if (LhsT->isObjectType() || LhsT->isFunctionType())
4294 LhsT = Self.Context.getRValueReferenceType(LhsT);
Eli Friedman1d4c3cf2012-08-14 02:06:07 +00004295
4296 // Build a fake source and destination for initialization.
Douglas Gregor8006e762011-01-27 20:28:01 +00004297 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
Douglas Gregorc03a1082011-01-28 02:26:04 +00004298 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
Douglas Gregor8006e762011-01-27 20:28:01 +00004299 Expr::getValueKindForType(LhsT));
4300 Expr *FromPtr = &From;
4301 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
4302 SourceLocation()));
4303
Eli Friedmana59b1902012-01-25 01:05:57 +00004304 // Perform the initialization in an unevaluated context within a SFINAE
4305 // trap at translation unit scope.
4306 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
Douglas Gregoredb76852011-01-27 22:31:44 +00004307 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4308 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004309 InitializationSequence Init(Self, To, Kind, FromPtr);
Sebastian Redlc7ca5872011-06-05 12:23:28 +00004310 if (Init.Failed())
Douglas Gregor8006e762011-01-27 20:28:01 +00004311 return false;
Douglas Gregoredb76852011-01-27 22:31:44 +00004312
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004313 ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
Douglas Gregor8006e762011-01-27 20:28:01 +00004314 return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
4315 }
Alp Toker73287bf2014-01-20 00:24:09 +00004316
4317 case BTT_IsNothrowAssignable:
Douglas Gregor1be329d2012-02-23 07:33:15 +00004318 case BTT_IsTriviallyAssignable: {
4319 // C++11 [meta.unary.prop]p3:
4320 // is_trivially_assignable is defined as:
4321 // is_assignable<T, U>::value is true and the assignment, as defined by
4322 // is_assignable, is known to call no operation that is not trivial
4323 //
4324 // is_assignable is defined as:
4325 // The expression declval<T>() = declval<U>() is well-formed when
4326 // treated as an unevaluated operand (Clause 5).
4327 //
4328 // For both, T and U shall be complete types, (possibly cv-qualified)
4329 // void, or arrays of unknown bound.
4330 if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
4331 Self.RequireCompleteType(KeyLoc, LhsT,
4332 diag::err_incomplete_type_used_in_type_trait_expr))
4333 return false;
4334 if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
4335 Self.RequireCompleteType(KeyLoc, RhsT,
4336 diag::err_incomplete_type_used_in_type_trait_expr))
4337 return false;
4338
4339 // cv void is never assignable.
4340 if (LhsT->isVoidType() || RhsT->isVoidType())
4341 return false;
4342
4343 // Build expressions that emulate the effect of declval<T>() and
4344 // declval<U>().
4345 if (LhsT->isObjectType() || LhsT->isFunctionType())
4346 LhsT = Self.Context.getRValueReferenceType(LhsT);
4347 if (RhsT->isObjectType() || RhsT->isFunctionType())
4348 RhsT = Self.Context.getRValueReferenceType(RhsT);
4349 OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
4350 Expr::getValueKindForType(LhsT));
4351 OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context),
4352 Expr::getValueKindForType(RhsT));
4353
4354 // Attempt the assignment in an unevaluated context within a SFINAE
4355 // trap at translation unit scope.
4356 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
4357 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
4358 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
Craig Topperc3ec1492014-05-26 06:22:03 +00004359 ExprResult Result = Self.BuildBinOp(/*S=*/nullptr, KeyLoc, BO_Assign, &Lhs,
4360 &Rhs);
Douglas Gregor1be329d2012-02-23 07:33:15 +00004361 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4362 return false;
4363
Alp Toker73287bf2014-01-20 00:24:09 +00004364 if (BTT == BTT_IsNothrowAssignable)
4365 return Self.canThrow(Result.get()) == CT_Cannot;
Douglas Gregor6bd56ca2012-06-29 00:49:17 +00004366
Alp Toker73287bf2014-01-20 00:24:09 +00004367 if (BTT == BTT_IsTriviallyAssignable) {
4368 // Under Objective-C ARC, if the destination has non-trivial Objective-C
4369 // lifetime, this is a non-trivial assignment.
4370 if (Self.getLangOpts().ObjCAutoRefCount &&
4371 hasNontrivialObjCLifetime(LhsT.getNonReferenceType()))
4372 return false;
4373
4374 return !Result.get()->hasNonTrivialCall(Self.Context);
4375 }
4376
4377 llvm_unreachable("unhandled type trait");
4378 return false;
Douglas Gregor1be329d2012-02-23 07:33:15 +00004379 }
Alp Tokercbb90342013-12-13 20:49:58 +00004380 default: llvm_unreachable("not a BTT");
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00004381 }
4382 llvm_unreachable("Unknown type trait or not implemented");
4383}
4384
John Wiegley6242b6a2011-04-28 00:16:57 +00004385ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
4386 SourceLocation KWLoc,
4387 ParsedType Ty,
4388 Expr* DimExpr,
4389 SourceLocation RParen) {
4390 TypeSourceInfo *TSInfo;
4391 QualType T = GetTypeFromParser(Ty, &TSInfo);
4392 if (!TSInfo)
4393 TSInfo = Context.getTrivialTypeSourceInfo(T);
4394
4395 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
4396}
4397
4398static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
4399 QualType T, Expr *DimExpr,
4400 SourceLocation KeyLoc) {
Chandler Carruth0d1a54f2011-05-01 08:41:10 +00004401 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegley6242b6a2011-04-28 00:16:57 +00004402
4403 switch(ATT) {
4404 case ATT_ArrayRank:
4405 if (T->isArrayType()) {
4406 unsigned Dim = 0;
4407 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
4408 ++Dim;
4409 T = AT->getElementType();
4410 }
4411 return Dim;
John Wiegley6242b6a2011-04-28 00:16:57 +00004412 }
John Wiegleyd3522222011-04-28 02:06:46 +00004413 return 0;
4414
John Wiegley6242b6a2011-04-28 00:16:57 +00004415 case ATT_ArrayExtent: {
4416 llvm::APSInt Value;
4417 uint64_t Dim;
Richard Smithf4c51d92012-02-04 09:53:13 +00004418 if (Self.VerifyIntegerConstantExpression(DimExpr, &Value,
Douglas Gregore2b37442012-05-04 22:38:52 +00004419 diag::err_dimension_expr_not_constant_integer,
Richard Smithf4c51d92012-02-04 09:53:13 +00004420 false).isInvalid())
4421 return 0;
4422 if (Value.isSigned() && Value.isNegative()) {
Daniel Dunbar900cead2012-03-09 21:38:22 +00004423 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
4424 << DimExpr->getSourceRange();
Richard Smithf4c51d92012-02-04 09:53:13 +00004425 return 0;
John Wiegleyd3522222011-04-28 02:06:46 +00004426 }
Richard Smithf4c51d92012-02-04 09:53:13 +00004427 Dim = Value.getLimitedValue();
John Wiegley6242b6a2011-04-28 00:16:57 +00004428
4429 if (T->isArrayType()) {
4430 unsigned D = 0;
4431 bool Matched = false;
4432 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
4433 if (Dim == D) {
4434 Matched = true;
4435 break;
4436 }
4437 ++D;
4438 T = AT->getElementType();
4439 }
4440
John Wiegleyd3522222011-04-28 02:06:46 +00004441 if (Matched && T->isArrayType()) {
4442 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
4443 return CAT->getSize().getLimitedValue();
4444 }
John Wiegley6242b6a2011-04-28 00:16:57 +00004445 }
John Wiegleyd3522222011-04-28 02:06:46 +00004446 return 0;
John Wiegley6242b6a2011-04-28 00:16:57 +00004447 }
4448 }
4449 llvm_unreachable("Unknown type trait or not implemented");
4450}
4451
4452ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT,
4453 SourceLocation KWLoc,
4454 TypeSourceInfo *TSInfo,
4455 Expr* DimExpr,
4456 SourceLocation RParen) {
4457 QualType T = TSInfo->getType();
John Wiegley6242b6a2011-04-28 00:16:57 +00004458
Chandler Carruthc5276e52011-05-01 08:48:21 +00004459 // FIXME: This should likely be tracked as an APInt to remove any host
4460 // assumptions about the width of size_t on the target.
Chandler Carruth0d1a54f2011-05-01 08:41:10 +00004461 uint64_t Value = 0;
4462 if (!T->isDependentType())
4463 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
4464
Chandler Carruthc5276e52011-05-01 08:48:21 +00004465 // While the specification for these traits from the Embarcadero C++
4466 // compiler's documentation says the return type is 'unsigned int', Clang
4467 // returns 'size_t'. On Windows, the primary platform for the Embarcadero
4468 // compiler, there is no difference. On several other platforms this is an
4469 // important distinction.
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00004470 return new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, DimExpr,
4471 RParen, Context.getSizeType());
John Wiegley6242b6a2011-04-28 00:16:57 +00004472}
4473
John Wiegleyf9f65842011-04-25 06:54:41 +00004474ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET,
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004475 SourceLocation KWLoc,
4476 Expr *Queried,
4477 SourceLocation RParen) {
John Wiegleyf9f65842011-04-25 06:54:41 +00004478 // If error parsing the expression, ignore.
4479 if (!Queried)
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004480 return ExprError();
John Wiegleyf9f65842011-04-25 06:54:41 +00004481
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004482 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
John Wiegleyf9f65842011-04-25 06:54:41 +00004483
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004484 return Result;
John Wiegleyf9f65842011-04-25 06:54:41 +00004485}
4486
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004487static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
4488 switch (ET) {
4489 case ET_IsLValueExpr: return E->isLValue();
4490 case ET_IsRValueExpr: return E->isRValue();
4491 }
4492 llvm_unreachable("Expression trait not covered by switch");
4493}
4494
John Wiegleyf9f65842011-04-25 06:54:41 +00004495ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004496 SourceLocation KWLoc,
4497 Expr *Queried,
4498 SourceLocation RParen) {
John Wiegleyf9f65842011-04-25 06:54:41 +00004499 if (Queried->isTypeDependent()) {
4500 // Delay type-checking for type-dependent expressions.
4501 } else if (Queried->getType()->isPlaceholderType()) {
4502 ExprResult PE = CheckPlaceholderExpr(Queried);
4503 if (PE.isInvalid()) return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004504 return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen);
John Wiegleyf9f65842011-04-25 06:54:41 +00004505 }
4506
Chandler Carruth20b9bc82011-05-01 07:44:20 +00004507 bool Value = EvaluateExpressionTrait(ET, Queried);
Chandler Carruthf57eba32011-05-01 08:48:19 +00004508
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00004509 return new (Context)
4510 ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
John Wiegleyf9f65842011-04-25 06:54:41 +00004511}
4512
Richard Trieu82402a02011-09-15 21:56:47 +00004513QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
John McCall7decc9e2010-11-18 06:31:45 +00004514 ExprValueKind &VK,
4515 SourceLocation Loc,
4516 bool isIndirect) {
Richard Trieu82402a02011-09-15 21:56:47 +00004517 assert(!LHS.get()->getType()->isPlaceholderType() &&
4518 !RHS.get()->getType()->isPlaceholderType() &&
John McCall0b645e92011-06-30 17:15:34 +00004519 "placeholders should have been weeded out by now");
4520
4521 // The LHS undergoes lvalue conversions if this is ->*.
4522 if (isIndirect) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004523 LHS = DefaultLvalueConversion(LHS.get());
Richard Trieu82402a02011-09-15 21:56:47 +00004524 if (LHS.isInvalid()) return QualType();
John McCall0b645e92011-06-30 17:15:34 +00004525 }
4526
4527 // The RHS always undergoes lvalue conversions.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004528 RHS = DefaultLvalueConversion(RHS.get());
Richard Trieu82402a02011-09-15 21:56:47 +00004529 if (RHS.isInvalid()) return QualType();
John McCall0b645e92011-06-30 17:15:34 +00004530
Sebastian Redl5822f082009-02-07 20:10:22 +00004531 const char *OpSpelling = isIndirect ? "->*" : ".*";
4532 // C++ 5.5p2
4533 // The binary operator .* [p3: ->*] binds its second operand, which shall
4534 // be of type "pointer to member of T" (where T is a completely-defined
4535 // class type) [...]
Richard Trieu82402a02011-09-15 21:56:47 +00004536 QualType RHSType = RHS.get()->getType();
4537 const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>();
Douglas Gregorac1fb652009-03-24 19:52:54 +00004538 if (!MemPtr) {
Sebastian Redl5822f082009-02-07 20:10:22 +00004539 Diag(Loc, diag::err_bad_memptr_rhs)
Richard Trieu82402a02011-09-15 21:56:47 +00004540 << OpSpelling << RHSType << RHS.get()->getSourceRange();
Sebastian Redl5822f082009-02-07 20:10:22 +00004541 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00004542 }
Douglas Gregorac1fb652009-03-24 19:52:54 +00004543
Sebastian Redl5822f082009-02-07 20:10:22 +00004544 QualType Class(MemPtr->getClass(), 0);
4545
Douglas Gregord07ba342010-10-13 20:41:14 +00004546 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
4547 // member pointer points must be completely-defined. However, there is no
4548 // reason for this semantic distinction, and the rule is not enforced by
4549 // other compilers. Therefore, we do not check this property, as it is
4550 // likely to be considered a defect.
Sebastian Redlc72350e2010-04-10 10:14:54 +00004551
Sebastian Redl5822f082009-02-07 20:10:22 +00004552 // C++ 5.5p2
4553 // [...] to its first operand, which shall be of class T or of a class of
4554 // which T is an unambiguous and accessible base class. [p3: a pointer to
4555 // such a class]
Richard Trieu82402a02011-09-15 21:56:47 +00004556 QualType LHSType = LHS.get()->getType();
Sebastian Redl5822f082009-02-07 20:10:22 +00004557 if (isIndirect) {
Richard Trieu82402a02011-09-15 21:56:47 +00004558 if (const PointerType *Ptr = LHSType->getAs<PointerType>())
4559 LHSType = Ptr->getPointeeType();
Sebastian Redl5822f082009-02-07 20:10:22 +00004560 else {
4561 Diag(Loc, diag::err_bad_memptr_lhs)
Richard Trieu82402a02011-09-15 21:56:47 +00004562 << OpSpelling << 1 << LHSType
Douglas Gregora771f462010-03-31 17:46:05 +00004563 << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
Sebastian Redl5822f082009-02-07 20:10:22 +00004564 return QualType();
4565 }
4566 }
4567
Richard Trieu82402a02011-09-15 21:56:47 +00004568 if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
Sebastian Redl26a0f1c2010-04-23 17:18:26 +00004569 // If we want to check the hierarchy, we need a complete type.
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00004570 if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
4571 OpSpelling, (int)isIndirect)) {
Sebastian Redl26a0f1c2010-04-23 17:18:26 +00004572 return QualType();
4573 }
Richard Smithdb05cd32013-12-12 03:40:18 +00004574
Richard Smith0f59cb32015-12-18 21:45:41 +00004575 if (!IsDerivedFrom(Loc, LHSType, Class)) {
Sebastian Redl5822f082009-02-07 20:10:22 +00004576 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
Richard Trieu82402a02011-09-15 21:56:47 +00004577 << (int)isIndirect << LHS.get()->getType();
Sebastian Redl5822f082009-02-07 20:10:22 +00004578 return QualType();
4579 }
Richard Smithdb05cd32013-12-12 03:40:18 +00004580
4581 CXXCastPath BasePath;
4582 if (CheckDerivedToBaseConversion(LHSType, Class, Loc,
4583 SourceRange(LHS.get()->getLocStart(),
4584 RHS.get()->getLocEnd()),
4585 &BasePath))
4586 return QualType();
4587
Eli Friedman1fcf66b2010-01-16 00:00:48 +00004588 // Cast LHS to type of use.
4589 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
Eli Friedmanbe4b3632011-09-27 21:58:52 +00004590 ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004591 LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK,
Richard Trieu82402a02011-09-15 21:56:47 +00004592 &BasePath);
Sebastian Redl5822f082009-02-07 20:10:22 +00004593 }
4594
Richard Trieu82402a02011-09-15 21:56:47 +00004595 if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) {
Fariborz Jahanian1bc0f9a2009-11-18 21:54:48 +00004596 // Diagnose use of pointer-to-member type which when used as
4597 // the functional cast in a pointer-to-member expression.
4598 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
4599 return QualType();
4600 }
John McCall7decc9e2010-11-18 06:31:45 +00004601
Sebastian Redl5822f082009-02-07 20:10:22 +00004602 // C++ 5.5p2
4603 // The result is an object or a function of the type specified by the
4604 // second operand.
4605 // The cv qualifiers are the union of those in the pointer and the left side,
4606 // in accordance with 5.5p5 and 5.2.5.
Sebastian Redl5822f082009-02-07 20:10:22 +00004607 QualType Result = MemPtr->getPointeeType();
Richard Trieu82402a02011-09-15 21:56:47 +00004608 Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
John McCall7decc9e2010-11-18 06:31:45 +00004609
Douglas Gregor1d042092011-01-26 16:40:18 +00004610 // C++0x [expr.mptr.oper]p6:
4611 // In a .* expression whose object expression is an rvalue, the program is
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004612 // ill-formed if the second operand is a pointer to member function with
4613 // ref-qualifier &. In a ->* expression or in a .* expression whose object
4614 // expression is an lvalue, the program is ill-formed if the second operand
Douglas Gregor1d042092011-01-26 16:40:18 +00004615 // is a pointer to member function with ref-qualifier &&.
4616 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
4617 switch (Proto->getRefQualifier()) {
4618 case RQ_None:
4619 // Do nothing
4620 break;
4621
4622 case RQ_LValue:
Richard Trieu82402a02011-09-15 21:56:47 +00004623 if (!isIndirect && !LHS.get()->Classify(Context).isLValue())
Douglas Gregor1d042092011-01-26 16:40:18 +00004624 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
Richard Trieu82402a02011-09-15 21:56:47 +00004625 << RHSType << 1 << LHS.get()->getSourceRange();
Douglas Gregor1d042092011-01-26 16:40:18 +00004626 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004627
Douglas Gregor1d042092011-01-26 16:40:18 +00004628 case RQ_RValue:
Richard Trieu82402a02011-09-15 21:56:47 +00004629 if (isIndirect || !LHS.get()->Classify(Context).isRValue())
Douglas Gregor1d042092011-01-26 16:40:18 +00004630 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
Richard Trieu82402a02011-09-15 21:56:47 +00004631 << RHSType << 0 << LHS.get()->getSourceRange();
Douglas Gregor1d042092011-01-26 16:40:18 +00004632 break;
4633 }
4634 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004635
John McCall7decc9e2010-11-18 06:31:45 +00004636 // C++ [expr.mptr.oper]p6:
4637 // The result of a .* expression whose second operand is a pointer
4638 // to a data member is of the same value category as its
4639 // first operand. The result of a .* expression whose second
4640 // operand is a pointer to a member function is a prvalue. The
4641 // result of an ->* expression is an lvalue if its second operand
4642 // is a pointer to data member and a prvalue otherwise.
John McCall0009fcc2011-04-26 20:42:42 +00004643 if (Result->isFunctionType()) {
John McCall7decc9e2010-11-18 06:31:45 +00004644 VK = VK_RValue;
John McCall0009fcc2011-04-26 20:42:42 +00004645 return Context.BoundMemberTy;
4646 } else if (isIndirect) {
John McCall7decc9e2010-11-18 06:31:45 +00004647 VK = VK_LValue;
John McCall0009fcc2011-04-26 20:42:42 +00004648 } else {
Richard Trieu82402a02011-09-15 21:56:47 +00004649 VK = LHS.get()->getValueKind();
John McCall0009fcc2011-04-26 20:42:42 +00004650 }
John McCall7decc9e2010-11-18 06:31:45 +00004651
Sebastian Redl5822f082009-02-07 20:10:22 +00004652 return Result;
4653}
Sebastian Redl1a99f442009-04-16 17:51:27 +00004654
Sebastian Redl1a99f442009-04-16 17:51:27 +00004655/// \brief Try to convert a type to another according to C++0x 5.16p3.
4656///
4657/// This is part of the parameter validation for the ? operator. If either
4658/// value operand is a class type, the two operands are attempted to be
4659/// converted to each other. This function does the conversion in one direction.
Douglas Gregor838fcc32010-03-26 20:14:36 +00004660/// It returns true if the program is ill-formed and has already been diagnosed
4661/// as such.
Sebastian Redl1a99f442009-04-16 17:51:27 +00004662static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
4663 SourceLocation QuestionLoc,
Douglas Gregor838fcc32010-03-26 20:14:36 +00004664 bool &HaveConversion,
4665 QualType &ToType) {
4666 HaveConversion = false;
4667 ToType = To->getType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004668
4669 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
Douglas Gregor838fcc32010-03-26 20:14:36 +00004670 SourceLocation());
Sebastian Redl1a99f442009-04-16 17:51:27 +00004671 // C++0x 5.16p3
4672 // The process for determining whether an operand expression E1 of type T1
4673 // can be converted to match an operand expression E2 of type T2 is defined
4674 // as follows:
4675 // -- If E2 is an lvalue:
John McCall086a4642010-11-24 05:12:34 +00004676 bool ToIsLvalue = To->isLValue();
Douglas Gregorf9edf802010-03-26 20:59:55 +00004677 if (ToIsLvalue) {
Sebastian Redl1a99f442009-04-16 17:51:27 +00004678 // E1 can be converted to match E2 if E1 can be implicitly converted to
4679 // type "lvalue reference to T2", subject to the constraint that in the
4680 // conversion the reference must bind directly to E1.
Douglas Gregor838fcc32010-03-26 20:14:36 +00004681 QualType T = Self.Context.getLValueReferenceType(ToType);
4682 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004683
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004684 InitializationSequence InitSeq(Self, Entity, Kind, From);
Douglas Gregor838fcc32010-03-26 20:14:36 +00004685 if (InitSeq.isDirectReferenceBinding()) {
4686 ToType = T;
4687 HaveConversion = true;
4688 return false;
Sebastian Redl1a99f442009-04-16 17:51:27 +00004689 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004690
Douglas Gregor838fcc32010-03-26 20:14:36 +00004691 if (InitSeq.isAmbiguous())
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004692 return InitSeq.Diagnose(Self, Entity, Kind, From);
Sebastian Redl1a99f442009-04-16 17:51:27 +00004693 }
John McCall65eb8792010-02-25 01:37:24 +00004694
Sebastian Redl1a99f442009-04-16 17:51:27 +00004695 // -- If E2 is an rvalue, or if the conversion above cannot be done:
4696 // -- if E1 and E2 have class type, and the underlying class types are
4697 // the same or one is a base class of the other:
4698 QualType FTy = From->getType();
4699 QualType TTy = To->getType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004700 const RecordType *FRec = FTy->getAs<RecordType>();
4701 const RecordType *TRec = TTy->getAs<RecordType>();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004702 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
Richard Smith0f59cb32015-12-18 21:45:41 +00004703 Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
4704 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
4705 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
Sebastian Redl1a99f442009-04-16 17:51:27 +00004706 // E1 can be converted to match E2 if the class of T2 is the
4707 // same type as, or a base class of, the class of T1, and
4708 // [cv2 > cv1].
John McCall65eb8792010-02-25 01:37:24 +00004709 if (FRec == TRec || FDerivedFromT) {
4710 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
Douglas Gregor838fcc32010-03-26 20:14:36 +00004711 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004712 InitializationSequence InitSeq(Self, Entity, Kind, From);
Sebastian Redlc7ca5872011-06-05 12:23:28 +00004713 if (InitSeq) {
Douglas Gregor838fcc32010-03-26 20:14:36 +00004714 HaveConversion = true;
4715 return false;
4716 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004717
Douglas Gregor838fcc32010-03-26 20:14:36 +00004718 if (InitSeq.isAmbiguous())
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004719 return InitSeq.Diagnose(Self, Entity, Kind, From);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004720 }
Sebastian Redl1a99f442009-04-16 17:51:27 +00004721 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004722
Douglas Gregor838fcc32010-03-26 20:14:36 +00004723 return false;
Sebastian Redl1a99f442009-04-16 17:51:27 +00004724 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004725
Douglas Gregor838fcc32010-03-26 20:14:36 +00004726 // -- Otherwise: E1 can be converted to match E2 if E1 can be
4727 // implicitly converted to the type that expression E2 would have
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004728 // if E2 were converted to an rvalue (or the type it has, if E2 is
Douglas Gregorf9edf802010-03-26 20:59:55 +00004729 // an rvalue).
4730 //
4731 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
4732 // to the array-to-pointer or function-to-pointer conversions.
4733 if (!TTy->getAs<TagType>())
4734 TTy = TTy.getUnqualifiedType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004735
Douglas Gregor838fcc32010-03-26 20:14:36 +00004736 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004737 InitializationSequence InitSeq(Self, Entity, Kind, From);
Sebastian Redlc7ca5872011-06-05 12:23:28 +00004738 HaveConversion = !InitSeq.Failed();
Douglas Gregor838fcc32010-03-26 20:14:36 +00004739 ToType = TTy;
4740 if (InitSeq.isAmbiguous())
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004741 return InitSeq.Diagnose(Self, Entity, Kind, From);
Douglas Gregor838fcc32010-03-26 20:14:36 +00004742
Sebastian Redl1a99f442009-04-16 17:51:27 +00004743 return false;
4744}
4745
4746/// \brief Try to find a common type for two according to C++0x 5.16p5.
4747///
4748/// This is part of the parameter validation for the ? operator. If either
4749/// value operand is a class type, overload resolution is used to find a
4750/// conversion to a common type.
John Wiegley01296292011-04-08 18:41:53 +00004751static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004752 SourceLocation QuestionLoc) {
John Wiegley01296292011-04-08 18:41:53 +00004753 Expr *Args[2] = { LHS.get(), RHS.get() };
Richard Smith100b24a2014-04-17 01:52:14 +00004754 OverloadCandidateSet CandidateSet(QuestionLoc,
4755 OverloadCandidateSet::CSK_Operator);
Richard Smithe54c3072013-05-05 15:51:06 +00004756 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004757 CandidateSet);
Sebastian Redl1a99f442009-04-16 17:51:27 +00004758
4759 OverloadCandidateSet::iterator Best;
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004760 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
John Wiegley01296292011-04-08 18:41:53 +00004761 case OR_Success: {
Sebastian Redl1a99f442009-04-16 17:51:27 +00004762 // We found a match. Perform the conversions on the arguments and move on.
John Wiegley01296292011-04-08 18:41:53 +00004763 ExprResult LHSRes =
4764 Self.PerformImplicitConversion(LHS.get(), Best->BuiltinTypes.ParamTypes[0],
4765 Best->Conversions[0], Sema::AA_Converting);
4766 if (LHSRes.isInvalid())
Sebastian Redl1a99f442009-04-16 17:51:27 +00004767 break;
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004768 LHS = LHSRes;
John Wiegley01296292011-04-08 18:41:53 +00004769
4770 ExprResult RHSRes =
4771 Self.PerformImplicitConversion(RHS.get(), Best->BuiltinTypes.ParamTypes[1],
4772 Best->Conversions[1], Sema::AA_Converting);
4773 if (RHSRes.isInvalid())
4774 break;
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004775 RHS = RHSRes;
Chandler Carruth30141632011-02-25 19:41:05 +00004776 if (Best->Function)
Eli Friedmanfa0df832012-02-02 03:46:19 +00004777 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
Sebastian Redl1a99f442009-04-16 17:51:27 +00004778 return false;
John Wiegley01296292011-04-08 18:41:53 +00004779 }
4780
Douglas Gregor3e1e5272009-12-09 23:02:17 +00004781 case OR_No_Viable_Function:
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004782
4783 // Emit a better diagnostic if one of the expressions is a null pointer
4784 // constant and the other is a pointer type. In this case, the user most
4785 // likely forgot to take the address of the other expression.
John Wiegley01296292011-04-08 18:41:53 +00004786 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004787 return true;
4788
4789 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley01296292011-04-08 18:41:53 +00004790 << LHS.get()->getType() << RHS.get()->getType()
4791 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004792 return true;
4793
Douglas Gregor3e1e5272009-12-09 23:02:17 +00004794 case OR_Ambiguous:
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00004795 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
John Wiegley01296292011-04-08 18:41:53 +00004796 << LHS.get()->getType() << RHS.get()->getType()
4797 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Mike Stump87c57ac2009-05-16 07:39:55 +00004798 // FIXME: Print the possible common types by printing the return types of
4799 // the viable candidates.
Sebastian Redl1a99f442009-04-16 17:51:27 +00004800 break;
4801
Douglas Gregor3e1e5272009-12-09 23:02:17 +00004802 case OR_Deleted:
David Blaikie83d382b2011-09-23 05:06:16 +00004803 llvm_unreachable("Conditional operator has only built-in overloads");
Sebastian Redl1a99f442009-04-16 17:51:27 +00004804 }
4805 return true;
4806}
4807
Sebastian Redl5775af1a2009-04-17 16:30:52 +00004808/// \brief Perform an "extended" implicit conversion as returned by
4809/// TryClassUnification.
John Wiegley01296292011-04-08 18:41:53 +00004810static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) {
Douglas Gregor838fcc32010-03-26 20:14:36 +00004811 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
John Wiegley01296292011-04-08 18:41:53 +00004812 InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(),
Douglas Gregor838fcc32010-03-26 20:14:36 +00004813 SourceLocation());
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004814 Expr *Arg = E.get();
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004815 InitializationSequence InitSeq(Self, Entity, Kind, Arg);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004816 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg);
Douglas Gregor838fcc32010-03-26 20:14:36 +00004817 if (Result.isInvalid())
Sebastian Redl5775af1a2009-04-17 16:30:52 +00004818 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004819
John Wiegley01296292011-04-08 18:41:53 +00004820 E = Result;
Sebastian Redl5775af1a2009-04-17 16:30:52 +00004821 return false;
4822}
4823
Sebastian Redl1a99f442009-04-16 17:51:27 +00004824/// \brief Check the operands of ?: under C++ semantics.
4825///
4826/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
4827/// extension. In this case, LHS == Cond. (But they're not aliases.)
Richard Smithf2b084f2012-08-08 06:13:49 +00004828QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
4829 ExprResult &RHS, ExprValueKind &VK,
4830 ExprObjectKind &OK,
Sebastian Redl1a99f442009-04-16 17:51:27 +00004831 SourceLocation QuestionLoc) {
Mike Stump87c57ac2009-05-16 07:39:55 +00004832 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
4833 // interface pointers.
Sebastian Redl1a99f442009-04-16 17:51:27 +00004834
Richard Smith45edb702012-08-07 22:06:48 +00004835 // C++11 [expr.cond]p1
Sebastian Redl1a99f442009-04-16 17:51:27 +00004836 // The first expression is contextually converted to bool.
John Wiegley01296292011-04-08 18:41:53 +00004837 if (!Cond.get()->isTypeDependent()) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004838 ExprResult CondRes = CheckCXXBooleanCondition(Cond.get());
John Wiegley01296292011-04-08 18:41:53 +00004839 if (CondRes.isInvalid())
Sebastian Redl1a99f442009-04-16 17:51:27 +00004840 return QualType();
Benjamin Kramer62b95d82012-08-23 21:35:17 +00004841 Cond = CondRes;
Sebastian Redl1a99f442009-04-16 17:51:27 +00004842 }
4843
John McCall7decc9e2010-11-18 06:31:45 +00004844 // Assume r-value.
4845 VK = VK_RValue;
John McCall4bc41ae2010-11-18 19:01:18 +00004846 OK = OK_Ordinary;
John McCall7decc9e2010-11-18 06:31:45 +00004847
Sebastian Redl1a99f442009-04-16 17:51:27 +00004848 // Either of the arguments dependent?
John Wiegley01296292011-04-08 18:41:53 +00004849 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
Sebastian Redl1a99f442009-04-16 17:51:27 +00004850 return Context.DependentTy;
4851
Richard Smith45edb702012-08-07 22:06:48 +00004852 // C++11 [expr.cond]p2
Sebastian Redl1a99f442009-04-16 17:51:27 +00004853 // If either the second or the third operand has type (cv) void, ...
John Wiegley01296292011-04-08 18:41:53 +00004854 QualType LTy = LHS.get()->getType();
4855 QualType RTy = RHS.get()->getType();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004856 bool LVoid = LTy->isVoidType();
4857 bool RVoid = RTy->isVoidType();
4858 if (LVoid || RVoid) {
Richard Smith6a6a4bb2014-01-27 04:19:56 +00004859 // ... one of the following shall hold:
4860 // -- The second or the third operand (but not both) is a (possibly
4861 // parenthesized) throw-expression; the result is of the type
4862 // and value category of the other.
4863 bool LThrow = isa<CXXThrowExpr>(LHS.get()->IgnoreParenImpCasts());
4864 bool RThrow = isa<CXXThrowExpr>(RHS.get()->IgnoreParenImpCasts());
4865 if (LThrow != RThrow) {
4866 Expr *NonThrow = LThrow ? RHS.get() : LHS.get();
4867 VK = NonThrow->getValueKind();
4868 // DR (no number yet): the result is a bit-field if the
4869 // non-throw-expression operand is a bit-field.
4870 OK = NonThrow->getObjectKind();
4871 return NonThrow->getType();
Richard Smith45edb702012-08-07 22:06:48 +00004872 }
4873
Sebastian Redl1a99f442009-04-16 17:51:27 +00004874 // -- Both the second and third operands have type void; the result is of
Richard Smith45edb702012-08-07 22:06:48 +00004875 // type void and is a prvalue.
Sebastian Redl1a99f442009-04-16 17:51:27 +00004876 if (LVoid && RVoid)
4877 return Context.VoidTy;
4878
4879 // Neither holds, error.
4880 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
4881 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
John Wiegley01296292011-04-08 18:41:53 +00004882 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004883 return QualType();
4884 }
4885
4886 // Neither is void.
4887
Richard Smithf2b084f2012-08-08 06:13:49 +00004888 // C++11 [expr.cond]p3
Sebastian Redl1a99f442009-04-16 17:51:27 +00004889 // Otherwise, if the second and third operand have different types, and
Richard Smithf2b084f2012-08-08 06:13:49 +00004890 // either has (cv) class type [...] an attempt is made to convert each of
4891 // those operands to the type of the other.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004892 if (!Context.hasSameType(LTy, RTy) &&
Sebastian Redl1a99f442009-04-16 17:51:27 +00004893 (LTy->isRecordType() || RTy->isRecordType())) {
Sebastian Redl1a99f442009-04-16 17:51:27 +00004894 // These return true if a single direction is already ambiguous.
Douglas Gregor838fcc32010-03-26 20:14:36 +00004895 QualType L2RType, R2LType;
4896 bool HaveL2R, HaveR2L;
John Wiegley01296292011-04-08 18:41:53 +00004897 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
Sebastian Redl1a99f442009-04-16 17:51:27 +00004898 return QualType();
John Wiegley01296292011-04-08 18:41:53 +00004899 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
Sebastian Redl1a99f442009-04-16 17:51:27 +00004900 return QualType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004901
Sebastian Redl1a99f442009-04-16 17:51:27 +00004902 // If both can be converted, [...] the program is ill-formed.
4903 if (HaveL2R && HaveR2L) {
4904 Diag(QuestionLoc, diag::err_conditional_ambiguous)
John Wiegley01296292011-04-08 18:41:53 +00004905 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004906 return QualType();
4907 }
4908
4909 // If exactly one conversion is possible, that conversion is applied to
4910 // the chosen operand and the converted operands are used in place of the
4911 // original operands for the remainder of this section.
4912 if (HaveL2R) {
John Wiegley01296292011-04-08 18:41:53 +00004913 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
Sebastian Redl1a99f442009-04-16 17:51:27 +00004914 return QualType();
John Wiegley01296292011-04-08 18:41:53 +00004915 LTy = LHS.get()->getType();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004916 } else if (HaveR2L) {
John Wiegley01296292011-04-08 18:41:53 +00004917 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
Sebastian Redl1a99f442009-04-16 17:51:27 +00004918 return QualType();
John Wiegley01296292011-04-08 18:41:53 +00004919 RTy = RHS.get()->getType();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004920 }
4921 }
4922
Richard Smithf2b084f2012-08-08 06:13:49 +00004923 // C++11 [expr.cond]p3
4924 // if both are glvalues of the same value category and the same type except
4925 // for cv-qualification, an attempt is made to convert each of those
4926 // operands to the type of the other.
4927 ExprValueKind LVK = LHS.get()->getValueKind();
4928 ExprValueKind RVK = RHS.get()->getValueKind();
4929 if (!Context.hasSameType(LTy, RTy) &&
4930 Context.hasSameUnqualifiedType(LTy, RTy) &&
4931 LVK == RVK && LVK != VK_RValue) {
4932 // Since the unqualified types are reference-related and we require the
4933 // result to be as if a reference bound directly, the only conversion
4934 // we can perform is to add cv-qualifiers.
4935 Qualifiers LCVR = Qualifiers::fromCVRMask(LTy.getCVRQualifiers());
4936 Qualifiers RCVR = Qualifiers::fromCVRMask(RTy.getCVRQualifiers());
4937 if (RCVR.isStrictSupersetOf(LCVR)) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004938 LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK);
Richard Smithf2b084f2012-08-08 06:13:49 +00004939 LTy = LHS.get()->getType();
4940 }
4941 else if (LCVR.isStrictSupersetOf(RCVR)) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004942 RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK);
Richard Smithf2b084f2012-08-08 06:13:49 +00004943 RTy = RHS.get()->getType();
4944 }
4945 }
4946
4947 // C++11 [expr.cond]p4
John McCall7decc9e2010-11-18 06:31:45 +00004948 // If the second and third operands are glvalues of the same value
4949 // category and have the same type, the result is of that type and
4950 // value category and it is a bit-field if the second or the third
4951 // operand is a bit-field, or if both are bit-fields.
John McCall4bc41ae2010-11-18 19:01:18 +00004952 // We only extend this to bitfields, not to the crazy other kinds of
4953 // l-values.
Douglas Gregor697a3912010-04-01 22:47:07 +00004954 bool Same = Context.hasSameType(LTy, RTy);
Richard Smithf2b084f2012-08-08 06:13:49 +00004955 if (Same && LVK == RVK && LVK != VK_RValue &&
John Wiegley01296292011-04-08 18:41:53 +00004956 LHS.get()->isOrdinaryOrBitFieldObject() &&
4957 RHS.get()->isOrdinaryOrBitFieldObject()) {
4958 VK = LHS.get()->getValueKind();
4959 if (LHS.get()->getObjectKind() == OK_BitField ||
4960 RHS.get()->getObjectKind() == OK_BitField)
John McCall4bc41ae2010-11-18 19:01:18 +00004961 OK = OK_BitField;
John McCall7decc9e2010-11-18 06:31:45 +00004962 return LTy;
Fariborz Jahanianc60da032010-09-25 01:08:05 +00004963 }
Sebastian Redl1a99f442009-04-16 17:51:27 +00004964
Richard Smithf2b084f2012-08-08 06:13:49 +00004965 // C++11 [expr.cond]p5
4966 // Otherwise, the result is a prvalue. If the second and third operands
Sebastian Redl1a99f442009-04-16 17:51:27 +00004967 // do not have the same type, and either has (cv) class type, ...
4968 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
4969 // ... overload resolution is used to determine the conversions (if any)
4970 // to be applied to the operands. If the overload resolution fails, the
4971 // program is ill-formed.
4972 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
4973 return QualType();
4974 }
4975
Richard Smithf2b084f2012-08-08 06:13:49 +00004976 // C++11 [expr.cond]p6
4977 // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard
Sebastian Redl1a99f442009-04-16 17:51:27 +00004978 // conversions are performed on the second and third operands.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004979 LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
4980 RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
John Wiegley01296292011-04-08 18:41:53 +00004981 if (LHS.isInvalid() || RHS.isInvalid())
4982 return QualType();
4983 LTy = LHS.get()->getType();
4984 RTy = RHS.get()->getType();
Sebastian Redl1a99f442009-04-16 17:51:27 +00004985
4986 // After those conversions, one of the following shall hold:
4987 // -- The second and third operands have the same type; the result
Douglas Gregorfa6010b2010-05-19 23:40:50 +00004988 // is of that type. If the operands have class type, the result
4989 // is a prvalue temporary of the result type, which is
4990 // copy-initialized from either the second operand or the third
4991 // operand depending on the value of the first operand.
4992 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
4993 if (LTy->isRecordType()) {
4994 // The operands have class type. Make a temporary copy.
David Blaikie6154ef92012-09-10 22:05:41 +00004995 if (RequireNonAbstractType(QuestionLoc, LTy,
4996 diag::err_allocation_of_abstract_type))
4997 return QualType();
Douglas Gregorfa6010b2010-05-19 23:40:50 +00004998 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
David Blaikie6154ef92012-09-10 22:05:41 +00004999
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005000 ExprResult LHSCopy = PerformCopyInitialization(Entity,
5001 SourceLocation(),
John Wiegley01296292011-04-08 18:41:53 +00005002 LHS);
Douglas Gregorfa6010b2010-05-19 23:40:50 +00005003 if (LHSCopy.isInvalid())
5004 return QualType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005005
5006 ExprResult RHSCopy = PerformCopyInitialization(Entity,
5007 SourceLocation(),
John Wiegley01296292011-04-08 18:41:53 +00005008 RHS);
Douglas Gregorfa6010b2010-05-19 23:40:50 +00005009 if (RHSCopy.isInvalid())
5010 return QualType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005011
John Wiegley01296292011-04-08 18:41:53 +00005012 LHS = LHSCopy;
5013 RHS = RHSCopy;
Douglas Gregorfa6010b2010-05-19 23:40:50 +00005014 }
5015
Sebastian Redl1a99f442009-04-16 17:51:27 +00005016 return LTy;
Douglas Gregorfa6010b2010-05-19 23:40:50 +00005017 }
Sebastian Redl1a99f442009-04-16 17:51:27 +00005018
Douglas Gregor46188682010-05-18 22:42:18 +00005019 // Extension: conditional operator involving vector types.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005020 if (LTy->isVectorType() || RTy->isVectorType())
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00005021 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
5022 /*AllowBothBool*/true,
5023 /*AllowBoolConversions*/false);
Douglas Gregor46188682010-05-18 22:42:18 +00005024
Sebastian Redl1a99f442009-04-16 17:51:27 +00005025 // -- The second and third operands have arithmetic or enumeration type;
5026 // the usual arithmetic conversions are performed to bring them to a
5027 // common type, and the result is of that type.
5028 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
Anton Korobeynikov5f951ee2014-11-14 22:09:15 +00005029 QualType ResTy = UsualArithmeticConversions(LHS, RHS);
John Wiegley01296292011-04-08 18:41:53 +00005030 if (LHS.isInvalid() || RHS.isInvalid())
5031 return QualType();
Anton Korobeynikov5f951ee2014-11-14 22:09:15 +00005032
5033 LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
5034 RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
5035
5036 return ResTy;
Sebastian Redl1a99f442009-04-16 17:51:27 +00005037 }
5038
5039 // -- The second and third operands have pointer type, or one has pointer
Richard Smithf2b084f2012-08-08 06:13:49 +00005040 // type and the other is a null pointer constant, or both are null
5041 // pointer constants, at least one of which is non-integral; pointer
5042 // conversions and qualification conversions are performed to bring them
5043 // to their composite pointer type. The result is of the composite
5044 // pointer type.
Eli Friedman81390df2010-01-02 22:56:07 +00005045 // -- The second and third operands have pointer to member type, or one has
5046 // pointer to member type and the other is a null pointer constant;
5047 // pointer to member conversions and qualification conversions are
5048 // performed to bring them to a common type, whose cv-qualification
5049 // shall match the cv-qualification of either the second or the third
5050 // operand. The result is of the common type.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005051 bool NonStandardCompositeType = false;
Douglas Gregor19175ff2010-04-16 23:20:25 +00005052 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS,
Craig Topperc3ec1492014-05-26 06:22:03 +00005053 isSFINAEContext() ? nullptr
5054 : &NonStandardCompositeType);
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005055 if (!Composite.isNull()) {
5056 if (NonStandardCompositeType)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005057 Diag(QuestionLoc,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005058 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
5059 << LTy << RTy << Composite
John Wiegley01296292011-04-08 18:41:53 +00005060 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005061
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005062 return Composite;
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005063 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005064
Douglas Gregor697a3912010-04-01 22:47:07 +00005065 // Similarly, attempt to find composite type of two objective-c pointers.
Fariborz Jahanian798d2bd2009-12-10 20:46:08 +00005066 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
5067 if (!Composite.isNull())
5068 return Composite;
Sebastian Redl1a99f442009-04-16 17:51:27 +00005069
Chandler Carruth9c9127e2011-02-19 00:13:59 +00005070 // Check if we are using a null with a non-pointer type.
John Wiegley01296292011-04-08 18:41:53 +00005071 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carruth9c9127e2011-02-19 00:13:59 +00005072 return QualType();
5073
Sebastian Redl1a99f442009-04-16 17:51:27 +00005074 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley01296292011-04-08 18:41:53 +00005075 << LHS.get()->getType() << RHS.get()->getType()
5076 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl1a99f442009-04-16 17:51:27 +00005077 return QualType();
5078}
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005079
5080/// \brief Find a merged pointer type and convert the two expressions to it.
5081///
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005082/// This finds the composite pointer type (or member pointer type) for @p E1
Richard Smithf2b084f2012-08-08 06:13:49 +00005083/// and @p E2 according to C++11 5.9p2. It converts both expressions to this
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005084/// type and returns it.
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005085/// It does not emit diagnostics.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005086///
Douglas Gregor19175ff2010-04-16 23:20:25 +00005087/// \param Loc The location of the operator requiring these two expressions to
5088/// be converted to the composite pointer type.
5089///
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005090/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
5091/// a non-standard (but still sane) composite type to which both expressions
5092/// can be converted. When such a type is chosen, \c *NonStandardCompositeType
5093/// will be set true.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005094QualType Sema::FindCompositePointerType(SourceLocation Loc,
Douglas Gregor19175ff2010-04-16 23:20:25 +00005095 Expr *&E1, Expr *&E2,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005096 bool *NonStandardCompositeType) {
5097 if (NonStandardCompositeType)
5098 *NonStandardCompositeType = false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005099
David Blaikiebbafb8a2012-03-11 07:00:24 +00005100 assert(getLangOpts().CPlusPlus && "This function assumes C++");
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005101 QualType T1 = E1->getType(), T2 = E2->getType();
Mike Stump11289f42009-09-09 15:08:12 +00005102
Richard Smithf2b084f2012-08-08 06:13:49 +00005103 // C++11 5.9p2
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005104 // Pointer conversions and qualification conversions are performed on
5105 // pointer operands to bring them to their composite pointer type. If
5106 // one operand is a null pointer constant, the composite pointer type is
Richard Smithf2b084f2012-08-08 06:13:49 +00005107 // std::nullptr_t if the other operand is also a null pointer constant or,
5108 // if the other operand is a pointer, the type of the other operand.
5109 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
5110 !T2->isAnyPointerType() && !T2->isMemberPointerType()) {
5111 if (T1->isNullPtrType() &&
5112 E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005113 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get();
Richard Smithf2b084f2012-08-08 06:13:49 +00005114 return T1;
5115 }
5116 if (T2->isNullPtrType() &&
5117 E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005118 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get();
Richard Smithf2b084f2012-08-08 06:13:49 +00005119 return T2;
5120 }
5121 return QualType();
5122 }
5123
Douglas Gregor56751b52009-09-25 04:25:58 +00005124 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman06ed2a52009-10-20 08:27:19 +00005125 if (T2->isMemberPointerType())
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005126 E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00005127 else
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005128 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).get();
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005129 return T2;
5130 }
Douglas Gregor56751b52009-09-25 04:25:58 +00005131 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman06ed2a52009-10-20 08:27:19 +00005132 if (T1->isMemberPointerType())
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005133 E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).get();
Eli Friedman06ed2a52009-10-20 08:27:19 +00005134 else
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005135 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).get();
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005136 return T1;
5137 }
Mike Stump11289f42009-09-09 15:08:12 +00005138
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005139 // Now both have to be pointers or member pointers.
Sebastian Redl658262f2009-11-16 21:03:45 +00005140 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
5141 (!T2->isPointerType() && !T2->isMemberPointerType()))
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005142 return QualType();
5143
5144 // Otherwise, of one of the operands has type "pointer to cv1 void," then
5145 // the other has type "pointer to cv2 T" and the composite pointer type is
5146 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
5147 // Otherwise, the composite pointer type is a pointer type similar to the
5148 // type of one of the operands, with a cv-qualification signature that is
5149 // the union of the cv-qualification signatures of the operand types.
5150 // In practice, the first part here is redundant; it's subsumed by the second.
5151 // What we do here is, we build the two possible composite types, and try the
5152 // conversions in both directions. If only one works, or if the two composite
5153 // types are the same, we have succeeded.
John McCall8ccfcb52009-09-24 19:53:00 +00005154 // FIXME: extended qualifiers?
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005155 typedef SmallVector<unsigned, 4> QualifierVector;
Sebastian Redl658262f2009-11-16 21:03:45 +00005156 QualifierVector QualifierUnion;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005157 typedef SmallVector<std::pair<const Type *, const Type *>, 4>
Sebastian Redl658262f2009-11-16 21:03:45 +00005158 ContainingClassVector;
5159 ContainingClassVector MemberOfClass;
5160 QualType Composite1 = Context.getCanonicalType(T1),
5161 Composite2 = Context.getCanonicalType(T2);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005162 unsigned NeedConstBefore = 0;
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005163 do {
5164 const PointerType *Ptr1, *Ptr2;
5165 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
5166 (Ptr2 = Composite2->getAs<PointerType>())) {
5167 Composite1 = Ptr1->getPointeeType();
5168 Composite2 = Ptr2->getPointeeType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005169
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005170 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005171 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005172 if (NonStandardCompositeType &&
5173 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5174 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005175
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005176 QualifierUnion.push_back(
5177 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
Craig Topperc3ec1492014-05-26 06:22:03 +00005178 MemberOfClass.push_back(std::make_pair(nullptr, nullptr));
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005179 continue;
5180 }
Mike Stump11289f42009-09-09 15:08:12 +00005181
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005182 const MemberPointerType *MemPtr1, *MemPtr2;
5183 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
5184 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
5185 Composite1 = MemPtr1->getPointeeType();
5186 Composite2 = MemPtr2->getPointeeType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005187
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005188 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005189 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005190 if (NonStandardCompositeType &&
5191 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
5192 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005193
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005194 QualifierUnion.push_back(
5195 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
5196 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
5197 MemPtr2->getClass()));
5198 continue;
5199 }
Mike Stump11289f42009-09-09 15:08:12 +00005200
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005201 // FIXME: block pointer types?
Mike Stump11289f42009-09-09 15:08:12 +00005202
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005203 // Cannot unwrap any more types.
5204 break;
5205 } while (true);
Mike Stump11289f42009-09-09 15:08:12 +00005206
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005207 if (NeedConstBefore && NonStandardCompositeType) {
5208 // Extension: Add 'const' to qualifiers that come before the first qualifier
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005209 // mismatch, so that our (non-standard!) composite type meets the
Douglas Gregor6f5f6422010-02-25 22:29:57 +00005210 // requirements of C++ [conv.qual]p4 bullet 3.
5211 for (unsigned I = 0; I != NeedConstBefore; ++I) {
5212 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
5213 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
5214 *NonStandardCompositeType = true;
5215 }
5216 }
5217 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005218
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005219 // Rewrap the composites as pointers or member pointers with the union CVRs.
Sebastian Redl658262f2009-11-16 21:03:45 +00005220 ContainingClassVector::reverse_iterator MOC
5221 = MemberOfClass.rbegin();
5222 for (QualifierVector::reverse_iterator
5223 I = QualifierUnion.rbegin(),
5224 E = QualifierUnion.rend();
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005225 I != E; (void)++I, ++MOC) {
John McCall8ccfcb52009-09-24 19:53:00 +00005226 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005227 if (MOC->first && MOC->second) {
5228 // Rebuild member pointer type
John McCall8ccfcb52009-09-24 19:53:00 +00005229 Composite1 = Context.getMemberPointerType(
5230 Context.getQualifiedType(Composite1, Quals),
5231 MOC->first);
5232 Composite2 = Context.getMemberPointerType(
5233 Context.getQualifiedType(Composite2, Quals),
5234 MOC->second);
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005235 } else {
5236 // Rebuild pointer type
John McCall8ccfcb52009-09-24 19:53:00 +00005237 Composite1
5238 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
5239 Composite2
5240 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
Douglas Gregorb00b10e2009-08-24 17:42:35 +00005241 }
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005242 }
5243
Douglas Gregor19175ff2010-04-16 23:20:25 +00005244 // Try to convert to the first composite pointer type.
5245 InitializedEntity Entity1
5246 = InitializedEntity::InitializeTemporary(Composite1);
5247 InitializationKind Kind
5248 = InitializationKind::CreateCopy(Loc, SourceLocation());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00005249 InitializationSequence E1ToC1(*this, Entity1, Kind, E1);
5250 InitializationSequence E2ToC1(*this, Entity1, Kind, E2);
Mike Stump11289f42009-09-09 15:08:12 +00005251
Douglas Gregor19175ff2010-04-16 23:20:25 +00005252 if (E1ToC1 && E2ToC1) {
5253 // Conversion to Composite1 is viable.
5254 if (!Context.hasSameType(Composite1, Composite2)) {
5255 // Composite2 is a different type from Composite1. Check whether
5256 // Composite2 is also viable.
5257 InitializedEntity Entity2
5258 = InitializedEntity::InitializeTemporary(Composite2);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00005259 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
5260 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005261 if (E1ToC2 && E2ToC2) {
5262 // Both Composite1 and Composite2 are viable and are different;
5263 // this is an ambiguity.
5264 return QualType();
5265 }
5266 }
5267
5268 // Convert E1 to Composite1
John McCalldadc5752010-08-24 06:29:42 +00005269 ExprResult E1Result
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00005270 = E1ToC1.Perform(*this, Entity1, Kind, E1);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005271 if (E1Result.isInvalid())
5272 return QualType();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005273 E1 = E1Result.getAs<Expr>();
Douglas Gregor19175ff2010-04-16 23:20:25 +00005274
5275 // Convert E2 to Composite1
John McCalldadc5752010-08-24 06:29:42 +00005276 ExprResult E2Result
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00005277 = E2ToC1.Perform(*this, Entity1, Kind, E2);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005278 if (E2Result.isInvalid())
5279 return QualType();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005280 E2 = E2Result.getAs<Expr>();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005281
Douglas Gregor19175ff2010-04-16 23:20:25 +00005282 return Composite1;
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005283 }
5284
Douglas Gregor19175ff2010-04-16 23:20:25 +00005285 // Check whether Composite2 is viable.
5286 InitializedEntity Entity2
5287 = InitializedEntity::InitializeTemporary(Composite2);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00005288 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
5289 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005290 if (!E1ToC2 || !E2ToC2)
5291 return QualType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005292
Douglas Gregor19175ff2010-04-16 23:20:25 +00005293 // Convert E1 to Composite2
John McCalldadc5752010-08-24 06:29:42 +00005294 ExprResult E1Result
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00005295 = E1ToC2.Perform(*this, Entity2, Kind, E1);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005296 if (E1Result.isInvalid())
5297 return QualType();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005298 E1 = E1Result.getAs<Expr>();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005299
Douglas Gregor19175ff2010-04-16 23:20:25 +00005300 // Convert E2 to Composite2
John McCalldadc5752010-08-24 06:29:42 +00005301 ExprResult E2Result
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00005302 = E2ToC2.Perform(*this, Entity2, Kind, E2);
Douglas Gregor19175ff2010-04-16 23:20:25 +00005303 if (E2Result.isInvalid())
5304 return QualType();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005305 E2 = E2Result.getAs<Expr>();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005306
Douglas Gregor19175ff2010-04-16 23:20:25 +00005307 return Composite2;
Sebastian Redl3b7ef5e2009-04-19 19:26:31 +00005308}
Anders Carlsson85a307d2009-05-17 18:41:29 +00005309
John McCalldadc5752010-08-24 06:29:42 +00005310ExprResult Sema::MaybeBindToTemporary(Expr *E) {
Douglas Gregor298087b2010-11-01 21:10:29 +00005311 if (!E)
5312 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005313
John McCall31168b02011-06-15 23:02:42 +00005314 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
5315
5316 // If the result is a glvalue, we shouldn't bind it.
5317 if (!E->isRValue())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005318 return E;
Mike Stump11289f42009-09-09 15:08:12 +00005319
John McCall31168b02011-06-15 23:02:42 +00005320 // In ARC, calls that return a retainable type can return retained,
5321 // in which case we have to insert a consuming cast.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005322 if (getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00005323 E->getType()->isObjCRetainableType()) {
5324
5325 bool ReturnsRetained;
5326
5327 // For actual calls, we compute this by examining the type of the
5328 // called value.
5329 if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
5330 Expr *Callee = Call->getCallee()->IgnoreParens();
5331 QualType T = Callee->getType();
5332
5333 if (T == Context.BoundMemberTy) {
5334 // Handle pointer-to-members.
5335 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee))
5336 T = BinOp->getRHS()->getType();
5337 else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
5338 T = Mem->getMemberDecl()->getType();
5339 }
5340
5341 if (const PointerType *Ptr = T->getAs<PointerType>())
5342 T = Ptr->getPointeeType();
5343 else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>())
5344 T = Ptr->getPointeeType();
5345 else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>())
5346 T = MemPtr->getPointeeType();
5347
5348 const FunctionType *FTy = T->getAs<FunctionType>();
5349 assert(FTy && "call to value not of function type?");
5350 ReturnsRetained = FTy->getExtInfo().getProducesResult();
5351
5352 // ActOnStmtExpr arranges things so that StmtExprs of retainable
5353 // type always produce a +1 object.
5354 } else if (isa<StmtExpr>(E)) {
5355 ReturnsRetained = true;
5356
Ted Kremeneke65b0862012-03-06 20:05:56 +00005357 // We hit this case with the lambda conversion-to-block optimization;
5358 // we don't want any extra casts here.
5359 } else if (isa<CastExpr>(E) &&
5360 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005361 return E;
Ted Kremeneke65b0862012-03-06 20:05:56 +00005362
John McCall31168b02011-06-15 23:02:42 +00005363 // For message sends and property references, we try to find an
5364 // actual method. FIXME: we should infer retention by selector in
5365 // cases where we don't have an actual method.
Ted Kremeneke65b0862012-03-06 20:05:56 +00005366 } else {
Craig Topperc3ec1492014-05-26 06:22:03 +00005367 ObjCMethodDecl *D = nullptr;
Ted Kremeneke65b0862012-03-06 20:05:56 +00005368 if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) {
5369 D = Send->getMethodDecl();
Patrick Beard0caa3942012-04-19 00:25:12 +00005370 } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
5371 D = BoxedExpr->getBoxingMethod();
Ted Kremeneke65b0862012-03-06 20:05:56 +00005372 } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) {
5373 D = ArrayLit->getArrayWithObjectsMethod();
5374 } else if (ObjCDictionaryLiteral *DictLit
5375 = dyn_cast<ObjCDictionaryLiteral>(E)) {
5376 D = DictLit->getDictWithObjectsMethod();
5377 }
John McCall31168b02011-06-15 23:02:42 +00005378
5379 ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>());
John McCall32a4da02011-08-03 07:02:44 +00005380
5381 // Don't do reclaims on performSelector calls; despite their
5382 // return type, the invoked method doesn't necessarily actually
5383 // return an object.
5384 if (!ReturnsRetained &&
5385 D && D->getMethodFamily() == OMF_performSelector)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005386 return E;
John McCall31168b02011-06-15 23:02:42 +00005387 }
5388
John McCall16de4d22011-11-14 19:53:16 +00005389 // Don't reclaim an object of Class type.
5390 if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005391 return E;
John McCall16de4d22011-11-14 19:53:16 +00005392
John McCall4db5c3c2011-07-07 06:58:02 +00005393 ExprNeedsCleanups = true;
5394
John McCall2d637d22011-09-10 06:18:15 +00005395 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
5396 : CK_ARCReclaimReturnedObject);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005397 return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
5398 VK_RValue);
John McCall31168b02011-06-15 23:02:42 +00005399 }
5400
David Blaikiebbafb8a2012-03-11 07:00:24 +00005401 if (!getLangOpts().CPlusPlus)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005402 return E;
Douglas Gregor363b1512009-12-24 18:51:59 +00005403
Peter Collingbournec331a1e2012-01-26 03:33:51 +00005404 // Search for the base element type (cf. ASTContext::getBaseElementType) with
5405 // a fast path for the common case that the type is directly a RecordType.
5406 const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
Craig Topperc3ec1492014-05-26 06:22:03 +00005407 const RecordType *RT = nullptr;
Peter Collingbournec331a1e2012-01-26 03:33:51 +00005408 while (!RT) {
5409 switch (T->getTypeClass()) {
5410 case Type::Record:
5411 RT = cast<RecordType>(T);
5412 break;
5413 case Type::ConstantArray:
5414 case Type::IncompleteArray:
5415 case Type::VariableArray:
5416 case Type::DependentSizedArray:
5417 T = cast<ArrayType>(T)->getElementType().getTypePtr();
5418 break;
5419 default:
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005420 return E;
Peter Collingbournec331a1e2012-01-26 03:33:51 +00005421 }
5422 }
Mike Stump11289f42009-09-09 15:08:12 +00005423
Richard Smithfd555f62012-02-22 02:04:18 +00005424 // That should be enough to guarantee that this type is complete, if we're
5425 // not processing a decltype expression.
Jeffrey Yasskinbbc4eea2011-01-27 19:17:54 +00005426 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Richard Smitheec915d62012-02-18 04:13:32 +00005427 if (RD->isInvalidDecl() || RD->isDependentContext())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005428 return E;
Richard Smithfd555f62012-02-22 02:04:18 +00005429
5430 bool IsDecltype = ExprEvalContexts.back().IsDecltype;
Craig Topperc3ec1492014-05-26 06:22:03 +00005431 CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD);
John McCall31168b02011-06-15 23:02:42 +00005432
John McCall31168b02011-06-15 23:02:42 +00005433 if (Destructor) {
Eli Friedmanfa0df832012-02-02 03:46:19 +00005434 MarkFunctionReferenced(E->getExprLoc(), Destructor);
John McCall8e36d532010-04-07 00:41:46 +00005435 CheckDestructorAccess(E->getExprLoc(), Destructor,
5436 PDiag(diag::err_access_dtor_temp)
5437 << E->getType());
Richard Smith22262ab2013-05-04 06:44:46 +00005438 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
5439 return ExprError();
John McCall31168b02011-06-15 23:02:42 +00005440
Richard Smithfd555f62012-02-22 02:04:18 +00005441 // If destructor is trivial, we can avoid the extra copy.
5442 if (Destructor->isTrivial())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005443 return E;
Richard Smitheec915d62012-02-18 04:13:32 +00005444
John McCall28fc7092011-11-10 05:35:25 +00005445 // We need a cleanup, but we don't need to remember the temporary.
John McCall31168b02011-06-15 23:02:42 +00005446 ExprNeedsCleanups = true;
Richard Smithfd555f62012-02-22 02:04:18 +00005447 }
Richard Smitheec915d62012-02-18 04:13:32 +00005448
5449 CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor);
Richard Smithfd555f62012-02-22 02:04:18 +00005450 CXXBindTemporaryExpr *Bind = CXXBindTemporaryExpr::Create(Context, Temp, E);
5451
5452 if (IsDecltype)
5453 ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind);
5454
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005455 return Bind;
Anders Carlsson2d4cada2009-05-30 20:36:53 +00005456}
5457
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005458ExprResult
John McCall5d413782010-12-06 08:20:24 +00005459Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) {
Douglas Gregorb6ea6082009-12-22 22:17:25 +00005460 if (SubExpr.isInvalid())
5461 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005462
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005463 return MaybeCreateExprWithCleanups(SubExpr.get());
Douglas Gregorb6ea6082009-12-22 22:17:25 +00005464}
5465
John McCall28fc7092011-11-10 05:35:25 +00005466Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
Alp Toker028ed912013-12-06 17:56:43 +00005467 assert(SubExpr && "subexpression can't be null!");
John McCall28fc7092011-11-10 05:35:25 +00005468
Eli Friedman3bda6b12012-02-02 23:15:15 +00005469 CleanupVarDeclMarking();
5470
John McCall28fc7092011-11-10 05:35:25 +00005471 unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects;
5472 assert(ExprCleanupObjects.size() >= FirstCleanup);
5473 assert(ExprNeedsCleanups || ExprCleanupObjects.size() == FirstCleanup);
5474 if (!ExprNeedsCleanups)
5475 return SubExpr;
5476
Craig Topper5fc8fc22014-08-27 06:28:36 +00005477 auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
5478 ExprCleanupObjects.size() - FirstCleanup);
John McCall28fc7092011-11-10 05:35:25 +00005479
5480 Expr *E = ExprWithCleanups::Create(Context, SubExpr, Cleanups);
5481 DiscardCleanupsInEvaluationContext();
5482
5483 return E;
5484}
5485
John McCall5d413782010-12-06 08:20:24 +00005486Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
Alp Toker028ed912013-12-06 17:56:43 +00005487 assert(SubStmt && "sub-statement can't be null!");
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00005488
Eli Friedman3bda6b12012-02-02 23:15:15 +00005489 CleanupVarDeclMarking();
5490
John McCall31168b02011-06-15 23:02:42 +00005491 if (!ExprNeedsCleanups)
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00005492 return SubStmt;
5493
5494 // FIXME: In order to attach the temporaries, wrap the statement into
5495 // a StmtExpr; currently this is only used for asm statements.
5496 // This is hacky, either create a new CXXStmtWithTemporaries statement or
5497 // a new AsmStmtWithTemporaries.
Nico Webera2a0eb92012-12-29 20:03:39 +00005498 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, SubStmt,
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00005499 SourceLocation(),
5500 SourceLocation());
5501 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
5502 SourceLocation());
John McCall5d413782010-12-06 08:20:24 +00005503 return MaybeCreateExprWithCleanups(E);
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00005504}
5505
Richard Smithfd555f62012-02-22 02:04:18 +00005506/// Process the expression contained within a decltype. For such expressions,
5507/// certain semantic checks on temporaries are delayed until this point, and
5508/// are omitted for the 'topmost' call in the decltype expression. If the
5509/// topmost call bound a temporary, strip that temporary off the expression.
5510ExprResult Sema::ActOnDecltypeExpression(Expr *E) {
Benjamin Kramer671f4c02012-11-15 15:18:42 +00005511 assert(ExprEvalContexts.back().IsDecltype && "not in a decltype expression");
Richard Smithfd555f62012-02-22 02:04:18 +00005512
5513 // C++11 [expr.call]p11:
5514 // If a function call is a prvalue of object type,
5515 // -- if the function call is either
5516 // -- the operand of a decltype-specifier, or
5517 // -- the right operand of a comma operator that is the operand of a
5518 // decltype-specifier,
5519 // a temporary object is not introduced for the prvalue.
5520
5521 // Recursively rebuild ParenExprs and comma expressions to strip out the
5522 // outermost CXXBindTemporaryExpr, if any.
5523 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
5524 ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr());
5525 if (SubExpr.isInvalid())
5526 return ExprError();
5527 if (SubExpr.get() == PE->getSubExpr())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005528 return E;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005529 return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
Richard Smithfd555f62012-02-22 02:04:18 +00005530 }
5531 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
5532 if (BO->getOpcode() == BO_Comma) {
5533 ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
5534 if (RHS.isInvalid())
5535 return ExprError();
5536 if (RHS.get() == BO->getRHS())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005537 return E;
5538 return new (Context) BinaryOperator(
5539 BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(),
5540 BO->getObjectKind(), BO->getOperatorLoc(), BO->isFPContractable());
Richard Smithfd555f62012-02-22 02:04:18 +00005541 }
5542 }
5543
5544 CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
Craig Topperc3ec1492014-05-26 06:22:03 +00005545 CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
5546 : nullptr;
Richard Smith202dc132014-02-18 03:51:47 +00005547 if (TopCall)
5548 E = TopCall;
5549 else
Craig Topperc3ec1492014-05-26 06:22:03 +00005550 TopBind = nullptr;
Richard Smithfd555f62012-02-22 02:04:18 +00005551
5552 // Disable the special decltype handling now.
Benjamin Kramer671f4c02012-11-15 15:18:42 +00005553 ExprEvalContexts.back().IsDecltype = false;
Richard Smithfd555f62012-02-22 02:04:18 +00005554
Richard Smithf86b0ae2012-07-28 19:54:11 +00005555 // In MS mode, don't perform any extra checking of call return types within a
5556 // decltype expression.
Alp Tokerbfa39342014-01-14 12:51:41 +00005557 if (getLangOpts().MSVCCompat)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005558 return E;
Richard Smithf86b0ae2012-07-28 19:54:11 +00005559
Richard Smithfd555f62012-02-22 02:04:18 +00005560 // Perform the semantic checks we delayed until this point.
Benjamin Kramer671f4c02012-11-15 15:18:42 +00005561 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size();
5562 I != N; ++I) {
5563 CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
Richard Smithfd555f62012-02-22 02:04:18 +00005564 if (Call == TopCall)
5565 continue;
5566
David Majnemerced8bdf2015-02-25 17:36:15 +00005567 if (CheckCallReturnType(Call->getCallReturnType(Context),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005568 Call->getLocStart(),
Richard Smithfd555f62012-02-22 02:04:18 +00005569 Call, Call->getDirectCallee()))
5570 return ExprError();
5571 }
5572
5573 // Now all relevant types are complete, check the destructors are accessible
5574 // and non-deleted, and annotate them on the temporaries.
Benjamin Kramer671f4c02012-11-15 15:18:42 +00005575 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size();
5576 I != N; ++I) {
5577 CXXBindTemporaryExpr *Bind =
5578 ExprEvalContexts.back().DelayedDecltypeBinds[I];
Richard Smithfd555f62012-02-22 02:04:18 +00005579 if (Bind == TopBind)
5580 continue;
5581
5582 CXXTemporary *Temp = Bind->getTemporary();
5583
5584 CXXRecordDecl *RD =
5585 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
5586 CXXDestructorDecl *Destructor = LookupDestructor(RD);
5587 Temp->setDestructor(Destructor);
5588
Richard Smith7d847b12012-05-11 22:20:10 +00005589 MarkFunctionReferenced(Bind->getExprLoc(), Destructor);
5590 CheckDestructorAccess(Bind->getExprLoc(), Destructor,
Richard Smithfd555f62012-02-22 02:04:18 +00005591 PDiag(diag::err_access_dtor_temp)
Richard Smith7d847b12012-05-11 22:20:10 +00005592 << Bind->getType());
Richard Smith22262ab2013-05-04 06:44:46 +00005593 if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc()))
5594 return ExprError();
Richard Smithfd555f62012-02-22 02:04:18 +00005595
5596 // We need a cleanup, but we don't need to remember the temporary.
5597 ExprNeedsCleanups = true;
5598 }
5599
5600 // Possibly strip off the top CXXBindTemporaryExpr.
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005601 return E;
Richard Smithfd555f62012-02-22 02:04:18 +00005602}
5603
Richard Smith79c927b2013-11-06 19:31:51 +00005604/// Note a set of 'operator->' functions that were used for a member access.
5605static void noteOperatorArrows(Sema &S,
Craig Topper00bbdcf2014-06-28 23:22:23 +00005606 ArrayRef<FunctionDecl *> OperatorArrows) {
Richard Smith79c927b2013-11-06 19:31:51 +00005607 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
5608 // FIXME: Make this configurable?
5609 unsigned Limit = 9;
5610 if (OperatorArrows.size() > Limit) {
5611 // Produce Limit-1 normal notes and one 'skipping' note.
5612 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
5613 SkipCount = OperatorArrows.size() - (Limit - 1);
5614 }
5615
5616 for (unsigned I = 0; I < OperatorArrows.size(); /**/) {
5617 if (I == SkipStart) {
5618 S.Diag(OperatorArrows[I]->getLocation(),
5619 diag::note_operator_arrows_suppressed)
5620 << SkipCount;
5621 I += SkipCount;
5622 } else {
5623 S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
5624 << OperatorArrows[I]->getCallResultType();
5625 ++I;
5626 }
5627 }
5628}
5629
Nico Weber964d3322015-02-16 22:35:45 +00005630ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
5631 SourceLocation OpLoc,
5632 tok::TokenKind OpKind,
5633 ParsedType &ObjectType,
5634 bool &MayBePseudoDestructor) {
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005635 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCalldadc5752010-08-24 06:29:42 +00005636 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
John McCallb268a282010-08-23 23:25:46 +00005637 if (Result.isInvalid()) return ExprError();
5638 Base = Result.get();
Mike Stump11289f42009-09-09 15:08:12 +00005639
John McCall526ab472011-10-25 17:37:35 +00005640 Result = CheckPlaceholderExpr(Base);
5641 if (Result.isInvalid()) return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005642 Base = Result.get();
John McCall526ab472011-10-25 17:37:35 +00005643
John McCallb268a282010-08-23 23:25:46 +00005644 QualType BaseType = Base->getType();
Douglas Gregore610ada2010-02-24 18:44:31 +00005645 MayBePseudoDestructor = false;
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005646 if (BaseType->isDependentType()) {
Douglas Gregor41127182009-11-04 22:49:18 +00005647 // If we have a pointer to a dependent type and are using the -> operator,
5648 // the object type is the type that the pointer points to. We might still
5649 // have enough information about that type to do something useful.
5650 if (OpKind == tok::arrow)
5651 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
5652 BaseType = Ptr->getPointeeType();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005653
John McCallba7bf592010-08-24 05:47:05 +00005654 ObjectType = ParsedType::make(BaseType);
Douglas Gregore610ada2010-02-24 18:44:31 +00005655 MayBePseudoDestructor = true;
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005656 return Base;
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005657 }
Mike Stump11289f42009-09-09 15:08:12 +00005658
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005659 // C++ [over.match.oper]p8:
Mike Stump11289f42009-09-09 15:08:12 +00005660 // [...] When operator->returns, the operator-> is applied to the value
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005661 // returned, with the original second operand.
5662 if (OpKind == tok::arrow) {
Richard Smith79c927b2013-11-06 19:31:51 +00005663 QualType StartingType = BaseType;
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005664 bool NoArrowOperatorFound = false;
5665 bool FirstIteration = true;
5666 FunctionDecl *CurFD = dyn_cast<FunctionDecl>(CurContext);
John McCallc1538c02009-09-30 01:01:30 +00005667 // The set of types we've considered so far.
John McCallbd0465b2009-09-30 01:30:54 +00005668 llvm::SmallPtrSet<CanQualType,8> CTypes;
Richard Smith79c927b2013-11-06 19:31:51 +00005669 SmallVector<FunctionDecl*, 8> OperatorArrows;
John McCallbd0465b2009-09-30 01:30:54 +00005670 CTypes.insert(Context.getCanonicalType(BaseType));
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005671
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005672 while (BaseType->isRecordType()) {
Richard Smith79c927b2013-11-06 19:31:51 +00005673 if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {
5674 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
Richard Smith9dbc5742013-11-06 19:43:09 +00005675 << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();
Richard Smith79c927b2013-11-06 19:31:51 +00005676 noteOperatorArrows(*this, OperatorArrows);
5677 Diag(OpLoc, diag::note_operator_arrow_depth)
5678 << getLangOpts().ArrowDepth;
5679 return ExprError();
5680 }
5681
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005682 Result = BuildOverloadedArrowExpr(
5683 S, Base, OpLoc,
5684 // When in a template specialization and on the first loop iteration,
5685 // potentially give the default diagnostic (with the fixit in a
5686 // separate note) instead of having the error reported back to here
5687 // and giving a diagnostic with a fixit attached to the error itself.
5688 (FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization())
Craig Topperc3ec1492014-05-26 06:22:03 +00005689 ? nullptr
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005690 : &NoArrowOperatorFound);
5691 if (Result.isInvalid()) {
5692 if (NoArrowOperatorFound) {
5693 if (FirstIteration) {
5694 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
Richard Smith9dbc5742013-11-06 19:43:09 +00005695 << BaseType << 1 << Base->getSourceRange()
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005696 << FixItHint::CreateReplacement(OpLoc, ".");
5697 OpKind = tok::period;
5698 break;
Kaelyn Uhrain957c8b12013-07-31 20:16:17 +00005699 }
5700 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
5701 << BaseType << Base->getSourceRange();
5702 CallExpr *CE = dyn_cast<CallExpr>(Base);
Craig Topperc3ec1492014-05-26 06:22:03 +00005703 if (Decl *CD = (CE ? CE->getCalleeDecl() : nullptr)) {
Kaelyn Uhrain957c8b12013-07-31 20:16:17 +00005704 Diag(CD->getLocStart(),
5705 diag::note_member_reference_arrow_from_operator_arrow);
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005706 }
5707 }
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005708 return ExprError();
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005709 }
John McCallb268a282010-08-23 23:25:46 +00005710 Base = Result.get();
5711 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
Richard Smith79c927b2013-11-06 19:31:51 +00005712 OperatorArrows.push_back(OpCall->getDirectCallee());
John McCallb268a282010-08-23 23:25:46 +00005713 BaseType = Base->getType();
John McCallc1538c02009-09-30 01:01:30 +00005714 CanQualType CBaseType = Context.getCanonicalType(BaseType);
David Blaikie82e95a32014-11-19 07:49:47 +00005715 if (!CTypes.insert(CBaseType).second) {
Richard Smith79c927b2013-11-06 19:31:51 +00005716 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
5717 noteOperatorArrows(*this, OperatorArrows);
Fariborz Jahanian10ce9582009-09-30 00:19:41 +00005718 return ExprError();
5719 }
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005720 FirstIteration = false;
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005721 }
Mike Stump11289f42009-09-09 15:08:12 +00005722
Kaelyn Uhrain0c51de42013-07-31 17:38:24 +00005723 if (OpKind == tok::arrow &&
5724 (BaseType->isPointerType() || BaseType->isObjCObjectPointerType()))
Douglas Gregore4f764f2009-11-20 19:58:21 +00005725 BaseType = BaseType->getPointeeType();
5726 }
Mike Stump11289f42009-09-09 15:08:12 +00005727
Douglas Gregorbf3a8262012-01-12 16:11:24 +00005728 // Objective-C properties allow "." access on Objective-C pointer types,
5729 // so adjust the base type to the object type itself.
5730 if (BaseType->isObjCObjectPointerType())
5731 BaseType = BaseType->getPointeeType();
5732
5733 // C++ [basic.lookup.classref]p2:
5734 // [...] If the type of the object expression is of pointer to scalar
5735 // type, the unqualified-id is looked up in the context of the complete
5736 // postfix-expression.
5737 //
5738 // This also indicates that we could be parsing a pseudo-destructor-name.
5739 // Note that Objective-C class and object types can be pseudo-destructor
John McCall9d145df2015-12-14 19:12:54 +00005740 // expressions or normal member (ivar or property) access expressions, and
5741 // it's legal for the type to be incomplete if this is a pseudo-destructor
5742 // call. We'll do more incomplete-type checks later in the lookup process,
5743 // so just skip this check for ObjC types.
Douglas Gregorbf3a8262012-01-12 16:11:24 +00005744 if (BaseType->isObjCObjectOrInterfaceType()) {
John McCall9d145df2015-12-14 19:12:54 +00005745 ObjectType = ParsedType::make(BaseType);
Douglas Gregorbf3a8262012-01-12 16:11:24 +00005746 MayBePseudoDestructor = true;
John McCall9d145df2015-12-14 19:12:54 +00005747 return Base;
Douglas Gregorbf3a8262012-01-12 16:11:24 +00005748 } else if (!BaseType->isRecordType()) {
John McCallba7bf592010-08-24 05:47:05 +00005749 ObjectType = ParsedType();
Douglas Gregore610ada2010-02-24 18:44:31 +00005750 MayBePseudoDestructor = true;
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00005751 return Base;
Douglas Gregor2b6ca462009-09-03 21:38:09 +00005752 }
Mike Stump11289f42009-09-09 15:08:12 +00005753
Douglas Gregor3024f072012-04-16 07:05:22 +00005754 // The object type must be complete (or dependent), or
5755 // C++11 [expr.prim.general]p3:
5756 // Unlike the object expression in other contexts, *this is not required to
5757 // be of complete type for purposes of class member access (5.2.5) outside
5758 // the member function body.
Douglas Gregor3fad6172009-11-17 05:17:33 +00005759 if (!BaseType->isDependentType() &&
Douglas Gregor3024f072012-04-16 07:05:22 +00005760 !isThisOutsideMemberFunctionBody(BaseType) &&
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00005761 RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
Douglas Gregor3fad6172009-11-17 05:17:33 +00005762 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005763
Douglas Gregor2b6ca462009-09-03 21:38:09 +00005764 // C++ [basic.lookup.classref]p2:
Mike Stump11289f42009-09-09 15:08:12 +00005765 // If the id-expression in a class member access (5.2.5) is an
Douglas Gregor3fad6172009-11-17 05:17:33 +00005766 // unqualified-id, and the type of the object expression is of a class
Douglas Gregor2b6ca462009-09-03 21:38:09 +00005767 // type C (or of pointer to a class type C), the unqualified-id is looked
5768 // up in the scope of class C. [...]
John McCallba7bf592010-08-24 05:47:05 +00005769 ObjectType = ParsedType::make(BaseType);
Benjamin Kramer62b95d82012-08-23 21:35:17 +00005770 return Base;
Douglas Gregorb7bfe792009-09-02 22:59:36 +00005771}
5772
Eli Friedman6601b552012-01-25 04:29:24 +00005773static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
David Blaikie1d578782011-12-16 16:03:09 +00005774 tok::TokenKind& OpKind, SourceLocation OpLoc) {
Eli Friedman6601b552012-01-25 04:29:24 +00005775 if (Base->hasPlaceholderType()) {
5776 ExprResult result = S.CheckPlaceholderExpr(Base);
5777 if (result.isInvalid()) return true;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005778 Base = result.get();
Eli Friedman6601b552012-01-25 04:29:24 +00005779 }
5780 ObjectType = Base->getType();
5781
David Blaikie1d578782011-12-16 16:03:09 +00005782 // C++ [expr.pseudo]p2:
5783 // The left-hand side of the dot operator shall be of scalar type. The
5784 // left-hand side of the arrow operator shall be of pointer to scalar type.
5785 // This scalar type is the object type.
Eli Friedman6601b552012-01-25 04:29:24 +00005786 // Note that this is rather different from the normal handling for the
5787 // arrow operator.
David Blaikie1d578782011-12-16 16:03:09 +00005788 if (OpKind == tok::arrow) {
5789 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
5790 ObjectType = Ptr->getPointeeType();
5791 } else if (!Base->isTypeDependent()) {
5792 // The user wrote "p->" when she probably meant "p."; fix it.
5793 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
5794 << ObjectType << true
5795 << FixItHint::CreateReplacement(OpLoc, ".");
5796 if (S.isSFINAEContext())
5797 return true;
5798
5799 OpKind = tok::period;
5800 }
5801 }
5802
5803 return false;
5804}
5805
John McCalldadc5752010-08-24 06:29:42 +00005806ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base,
John McCalla2c4e722011-02-25 05:21:17 +00005807 SourceLocation OpLoc,
5808 tok::TokenKind OpKind,
5809 const CXXScopeSpec &SS,
5810 TypeSourceInfo *ScopeTypeInfo,
5811 SourceLocation CCLoc,
5812 SourceLocation TildeLoc,
David Majnemerced8bdf2015-02-25 17:36:15 +00005813 PseudoDestructorTypeStorage Destructed) {
Douglas Gregor678f90d2010-02-25 01:56:36 +00005814 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005815
Eli Friedman0ce4de42012-01-25 04:35:06 +00005816 QualType ObjectType;
David Blaikie1d578782011-12-16 16:03:09 +00005817 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5818 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005819
Douglas Gregorc5c57342012-09-10 14:57:06 +00005820 if (!ObjectType->isDependentType() && !ObjectType->isScalarType() &&
5821 !ObjectType->isVectorType()) {
Alp Tokerbfa39342014-01-14 12:51:41 +00005822 if (getLangOpts().MSVCCompat && ObjectType->isVoidType())
Nico Weber4bc64992012-01-23 06:08:16 +00005823 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange();
Reid Klecknere5025072014-05-01 16:50:23 +00005824 else {
Nico Weber58829272012-01-23 05:50:57 +00005825 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
5826 << ObjectType << Base->getSourceRange();
Reid Klecknere5025072014-05-01 16:50:23 +00005827 return ExprError();
5828 }
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005829 }
5830
5831 // C++ [expr.pseudo]p2:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005832 // [...] The cv-unqualified versions of the object type and of the type
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005833 // designated by the pseudo-destructor-name shall be the same type.
Douglas Gregor678f90d2010-02-25 01:56:36 +00005834 if (DestructedTypeInfo) {
5835 QualType DestructedType = DestructedTypeInfo->getType();
5836 SourceLocation DestructedTypeStart
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00005837 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
John McCall31168b02011-06-15 23:02:42 +00005838 if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {
5839 if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
5840 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
5841 << ObjectType << DestructedType << Base->getSourceRange()
5842 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005843
John McCall31168b02011-06-15 23:02:42 +00005844 // Recover by setting the destructed type to the object type.
5845 DestructedType = ObjectType;
5846 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
Douglas Gregor678f90d2010-02-25 01:56:36 +00005847 DestructedTypeStart);
John McCall31168b02011-06-15 23:02:42 +00005848 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5849 } else if (DestructedType.getObjCLifetime() !=
5850 ObjectType.getObjCLifetime()) {
5851
5852 if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {
5853 // Okay: just pretend that the user provided the correctly-qualified
5854 // type.
5855 } else {
5856 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
5857 << ObjectType << DestructedType << Base->getSourceRange()
5858 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
5859 }
5860
5861 // Recover by setting the destructed type to the object type.
5862 DestructedType = ObjectType;
5863 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
5864 DestructedTypeStart);
5865 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5866 }
Douglas Gregor678f90d2010-02-25 01:56:36 +00005867 }
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005868 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005869
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005870 // C++ [expr.pseudo]p2:
5871 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
5872 // form
5873 //
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005874 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005875 //
5876 // shall designate the same scalar type.
5877 if (ScopeTypeInfo) {
5878 QualType ScopeType = ScopeTypeInfo->getType();
5879 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
John McCallb86a6b82010-06-11 17:36:40 +00005880 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005881
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00005882 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005883 diag::err_pseudo_dtor_type_mismatch)
John McCallb268a282010-08-23 23:25:46 +00005884 << ObjectType << ScopeType << Base->getSourceRange()
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00005885 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005886
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005887 ScopeType = QualType();
Craig Topperc3ec1492014-05-26 06:22:03 +00005888 ScopeTypeInfo = nullptr;
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005889 }
5890 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005891
John McCallb268a282010-08-23 23:25:46 +00005892 Expr *Result
5893 = new (Context) CXXPseudoDestructorExpr(Context, Base,
5894 OpKind == tok::arrow, OpLoc,
Douglas Gregora6ce6082011-02-25 18:19:59 +00005895 SS.getWithLocInContext(Context),
John McCallb268a282010-08-23 23:25:46 +00005896 ScopeTypeInfo,
5897 CCLoc,
5898 TildeLoc,
5899 Destructed);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005900
David Majnemerced8bdf2015-02-25 17:36:15 +00005901 return Result;
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005902}
5903
John McCalldadc5752010-08-24 06:29:42 +00005904ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
John McCalla2c4e722011-02-25 05:21:17 +00005905 SourceLocation OpLoc,
5906 tok::TokenKind OpKind,
5907 CXXScopeSpec &SS,
5908 UnqualifiedId &FirstTypeName,
5909 SourceLocation CCLoc,
5910 SourceLocation TildeLoc,
David Majnemerced8bdf2015-02-25 17:36:15 +00005911 UnqualifiedId &SecondTypeName) {
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005912 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5913 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5914 "Invalid first type name in pseudo-destructor");
5915 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5916 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5917 "Invalid second type name in pseudo-destructor");
5918
Eli Friedman0ce4de42012-01-25 04:35:06 +00005919 QualType ObjectType;
David Blaikie1d578782011-12-16 16:03:09 +00005920 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5921 return ExprError();
Douglas Gregor678f90d2010-02-25 01:56:36 +00005922
5923 // Compute the object type that we should use for name lookup purposes. Only
5924 // record types and dependent types matter.
John McCallba7bf592010-08-24 05:47:05 +00005925 ParsedType ObjectTypePtrForLookup;
Douglas Gregor678f90d2010-02-25 01:56:36 +00005926 if (!SS.isSet()) {
John McCalla2c4e722011-02-25 05:21:17 +00005927 if (ObjectType->isRecordType())
5928 ObjectTypePtrForLookup = ParsedType::make(ObjectType);
John McCallba7bf592010-08-24 05:47:05 +00005929 else if (ObjectType->isDependentType())
5930 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
Douglas Gregor678f90d2010-02-25 01:56:36 +00005931 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005932
5933 // Convert the name of the type being destructed (following the ~) into a
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005934 // type (with source-location information).
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005935 QualType DestructedType;
Craig Topperc3ec1492014-05-26 06:22:03 +00005936 TypeSourceInfo *DestructedTypeInfo = nullptr;
Douglas Gregor678f90d2010-02-25 01:56:36 +00005937 PseudoDestructorTypeStorage Destructed;
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005938 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005939 ParsedType T = getTypeName(*SecondTypeName.Identifier,
John McCallba7bf592010-08-24 05:47:05 +00005940 SecondTypeName.StartLocation,
Fariborz Jahanian87967422011-02-08 18:05:59 +00005941 S, &SS, true, false, ObjectTypePtrForLookup);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005942 if (!T &&
Douglas Gregor678f90d2010-02-25 01:56:36 +00005943 ((SS.isSet() && !computeDeclContext(SS, false)) ||
5944 (!SS.isSet() && ObjectType->isDependentType()))) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005945 // The name of the type being destroyed is a dependent name, and we
Douglas Gregor678f90d2010-02-25 01:56:36 +00005946 // couldn't find anything useful in scope. Just store the identifier and
5947 // it's location, and we'll perform (qualified) name lookup again at
5948 // template instantiation time.
5949 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
5950 SecondTypeName.StartLocation);
5951 } else if (!T) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005952 Diag(SecondTypeName.StartLocation,
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005953 diag::err_pseudo_dtor_destructor_non_type)
5954 << SecondTypeName.Identifier << ObjectType;
5955 if (isSFINAEContext())
5956 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005957
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005958 // Recover by assuming we had the right type all along.
5959 DestructedType = ObjectType;
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005960 } else
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005961 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005962 } else {
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005963 // Resolve the template-id to a type.
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005964 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00005965 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005966 TemplateId->NumArgs);
Douglas Gregore7c20652011-03-02 00:47:37 +00005967 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
Abramo Bagnara48c05be2012-02-06 14:41:24 +00005968 TemplateId->TemplateKWLoc,
Douglas Gregore7c20652011-03-02 00:47:37 +00005969 TemplateId->Template,
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005970 TemplateId->TemplateNameLoc,
5971 TemplateId->LAngleLoc,
5972 TemplateArgsPtr,
5973 TemplateId->RAngleLoc);
5974 if (T.isInvalid() || !T.get()) {
5975 // Recover by assuming we had the right type all along.
5976 DestructedType = ObjectType;
5977 } else
5978 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005979 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005980
5981 // If we've performed some kind of recovery, (re-)build the type source
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005982 // information.
Douglas Gregor678f90d2010-02-25 01:56:36 +00005983 if (!DestructedType.isNull()) {
5984 if (!DestructedTypeInfo)
5985 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005986 SecondTypeName.StartLocation);
Douglas Gregor678f90d2010-02-25 01:56:36 +00005987 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5988 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005989
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00005990 // Convert the name of the scope type (the type prior to '::') into a type.
Craig Topperc3ec1492014-05-26 06:22:03 +00005991 TypeSourceInfo *ScopeTypeInfo = nullptr;
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005992 QualType ScopeType;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005993 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005994 FirstTypeName.Identifier) {
5995 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005996 ParsedType T = getTypeName(*FirstTypeName.Identifier,
John McCallba7bf592010-08-24 05:47:05 +00005997 FirstTypeName.StartLocation,
Douglas Gregora6ce6082011-02-25 18:19:59 +00005998 S, &SS, true, false, ObjectTypePtrForLookup);
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00005999 if (!T) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006000 Diag(FirstTypeName.StartLocation,
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00006001 diag::err_pseudo_dtor_destructor_non_type)
6002 << FirstTypeName.Identifier << ObjectType;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006003
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00006004 if (isSFINAEContext())
6005 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006006
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00006007 // Just drop this type. It's unnecessary anyway.
6008 ScopeType = QualType();
6009 } else
6010 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00006011 } else {
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00006012 // Resolve the template-id to a type.
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00006013 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00006014 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00006015 TemplateId->NumArgs);
Douglas Gregore7c20652011-03-02 00:47:37 +00006016 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
Abramo Bagnara48c05be2012-02-06 14:41:24 +00006017 TemplateId->TemplateKWLoc,
Douglas Gregore7c20652011-03-02 00:47:37 +00006018 TemplateId->Template,
Douglas Gregorb1dd23f2010-02-24 22:38:50 +00006019 TemplateId->TemplateNameLoc,
6020 TemplateId->LAngleLoc,
6021 TemplateArgsPtr,
6022 TemplateId->RAngleLoc);
6023 if (T.isInvalid() || !T.get()) {
6024 // Recover by dropping this type.
6025 ScopeType = QualType();
6026 } else
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006027 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
Douglas Gregor0d5b0a12010-02-24 21:29:12 +00006028 }
6029 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006030
Douglas Gregor90ad9222010-02-24 23:02:30 +00006031 if (!ScopeType.isNull() && !ScopeTypeInfo)
6032 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
6033 FirstTypeName.StartLocation);
6034
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006035
John McCallb268a282010-08-23 23:25:46 +00006036 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
Douglas Gregorcdbd5152010-02-24 23:50:37 +00006037 ScopeTypeInfo, CCLoc, TildeLoc,
David Majnemerced8bdf2015-02-25 17:36:15 +00006038 Destructed);
Douglas Gregore610ada2010-02-24 18:44:31 +00006039}
6040
David Blaikie1d578782011-12-16 16:03:09 +00006041ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6042 SourceLocation OpLoc,
6043 tok::TokenKind OpKind,
6044 SourceLocation TildeLoc,
David Majnemerced8bdf2015-02-25 17:36:15 +00006045 const DeclSpec& DS) {
Eli Friedman0ce4de42012-01-25 04:35:06 +00006046 QualType ObjectType;
David Blaikie1d578782011-12-16 16:03:09 +00006047 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6048 return ExprError();
6049
Aaron Ballman6c93b3e2014-12-17 21:57:17 +00006050 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc(),
6051 false);
David Blaikie1d578782011-12-16 16:03:09 +00006052
6053 TypeLocBuilder TLB;
6054 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
6055 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
6056 TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
6057 PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
6058
6059 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),
Craig Topperc3ec1492014-05-26 06:22:03 +00006060 nullptr, SourceLocation(), TildeLoc,
David Majnemerced8bdf2015-02-25 17:36:15 +00006061 Destructed);
David Blaikie1d578782011-12-16 16:03:09 +00006062}
6063
John Wiegley01296292011-04-08 18:41:53 +00006064ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
Eli Friedman2fb85122012-03-01 01:30:04 +00006065 CXXConversionDecl *Method,
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00006066 bool HadMultipleCandidates) {
Eli Friedman98b01ed2012-03-01 04:01:32 +00006067 if (Method->getParent()->isLambda() &&
6068 Method->getConversionType()->isBlockPointerType()) {
6069 // This is a lambda coversion to block pointer; check if the argument
6070 // is a LambdaExpr.
6071 Expr *SubE = E;
6072 CastExpr *CE = dyn_cast<CastExpr>(SubE);
6073 if (CE && CE->getCastKind() == CK_NoOp)
6074 SubE = CE->getSubExpr();
6075 SubE = SubE->IgnoreParens();
6076 if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
6077 SubE = BE->getSubExpr();
6078 if (isa<LambdaExpr>(SubE)) {
6079 // For the conversion to block pointer on a lambda expression, we
6080 // construct a special BlockLiteral instead; this doesn't really make
6081 // a difference in ARC, but outside of ARC the resulting block literal
6082 // follows the normal lifetime rules for block literals instead of being
6083 // autoreleased.
6084 DiagnosticErrorTrap Trap(Diags);
6085 ExprResult Exp = BuildBlockForLambdaConversion(E->getExprLoc(),
6086 E->getExprLoc(),
6087 Method, E);
6088 if (Exp.isInvalid())
6089 Diag(E->getExprLoc(), diag::note_lambda_to_block_conv);
6090 return Exp;
6091 }
6092 }
Eli Friedman98b01ed2012-03-01 04:01:32 +00006093
Craig Topperc3ec1492014-05-26 06:22:03 +00006094 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/nullptr,
John Wiegley01296292011-04-08 18:41:53 +00006095 FoundDecl, Method);
6096 if (Exp.isInvalid())
Douglas Gregor668443e2011-01-20 00:18:04 +00006097 return true;
Eli Friedmanf7195532009-12-09 04:53:56 +00006098
Aaron Ballmanf4cb2be2015-03-24 15:07:53 +00006099 MemberExpr *ME = new (Context) MemberExpr(
6100 Exp.get(), /*IsArrow=*/false, SourceLocation(), Method, SourceLocation(),
6101 Context.BoundMemberTy, VK_RValue, OK_Ordinary);
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00006102 if (HadMultipleCandidates)
6103 ME->setHadMultipleCandidates(true);
Nick Lewyckya096b142013-02-12 08:08:54 +00006104 MarkMemberReferenced(ME);
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00006105
Alp Toker314cc812014-01-25 16:55:45 +00006106 QualType ResultType = Method->getReturnType();
John McCall7decc9e2010-11-18 06:31:45 +00006107 ExprValueKind VK = Expr::getValueKindForType(ResultType);
6108 ResultType = ResultType.getNonLValueExprType(Context);
6109
Douglas Gregor27381f32009-11-23 12:27:39 +00006110 CXXMemberCallExpr *CE =
Dmitri Gribenko78852e92013-05-05 20:40:26 +00006111 new (Context) CXXMemberCallExpr(Context, ME, None, ResultType, VK,
John Wiegley01296292011-04-08 18:41:53 +00006112 Exp.get()->getLocEnd());
Fariborz Jahanian78cfcb52009-09-28 23:23:40 +00006113 return CE;
6114}
6115
Sebastian Redl4202c0f2010-09-10 20:55:43 +00006116ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6117 SourceLocation RParen) {
Aaron Ballmanedc80842015-04-27 22:31:12 +00006118 // If the operand is an unresolved lookup expression, the expression is ill-
6119 // formed per [over.over]p1, because overloaded function names cannot be used
6120 // without arguments except in explicit contexts.
6121 ExprResult R = CheckPlaceholderExpr(Operand);
6122 if (R.isInvalid())
6123 return R;
6124
6125 // The operand may have been modified when checking the placeholder type.
6126 Operand = R.get();
6127
Aaron Ballman6c93b3e2014-12-17 21:57:17 +00006128 if (ActiveTemplateInstantiations.empty() &&
6129 Operand->HasSideEffects(Context, false)) {
6130 // The expression operand for noexcept is in an unevaluated expression
6131 // context, so side effects could result in unintended consequences.
6132 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
6133 }
6134
Richard Smithf623c962012-04-17 00:58:00 +00006135 CanThrowResult CanThrow = canThrow(Operand);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006136 return new (Context)
6137 CXXNoexceptExpr(Context.BoolTy, Operand, CanThrow, KeyLoc, RParen);
Sebastian Redl4202c0f2010-09-10 20:55:43 +00006138}
6139
6140ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation,
6141 Expr *Operand, SourceLocation RParen) {
6142 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
Sebastian Redl22e3a932010-09-10 20:55:37 +00006143}
6144
Eli Friedmanf798f652012-05-24 22:04:19 +00006145static bool IsSpecialDiscardedValue(Expr *E) {
6146 // In C++11, discarded-value expressions of a certain form are special,
6147 // according to [expr]p10:
6148 // The lvalue-to-rvalue conversion (4.1) is applied only if the
6149 // expression is an lvalue of volatile-qualified type and it has
6150 // one of the following forms:
6151 E = E->IgnoreParens();
6152
Eli Friedmanc49c2262012-05-24 22:36:31 +00006153 // - id-expression (5.1.1),
Eli Friedmanf798f652012-05-24 22:04:19 +00006154 if (isa<DeclRefExpr>(E))
6155 return true;
6156
Eli Friedmanc49c2262012-05-24 22:36:31 +00006157 // - subscripting (5.2.1),
Eli Friedmanf798f652012-05-24 22:04:19 +00006158 if (isa<ArraySubscriptExpr>(E))
6159 return true;
6160
Eli Friedmanc49c2262012-05-24 22:36:31 +00006161 // - class member access (5.2.5),
Eli Friedmanf798f652012-05-24 22:04:19 +00006162 if (isa<MemberExpr>(E))
6163 return true;
6164
Eli Friedmanc49c2262012-05-24 22:36:31 +00006165 // - indirection (5.3.1),
Eli Friedmanf798f652012-05-24 22:04:19 +00006166 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
6167 if (UO->getOpcode() == UO_Deref)
6168 return true;
6169
6170 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
Eli Friedmanc49c2262012-05-24 22:36:31 +00006171 // - pointer-to-member operation (5.5),
Eli Friedmanf798f652012-05-24 22:04:19 +00006172 if (BO->isPtrMemOp())
6173 return true;
6174
Eli Friedmanc49c2262012-05-24 22:36:31 +00006175 // - comma expression (5.18) where the right operand is one of the above.
Eli Friedmanf798f652012-05-24 22:04:19 +00006176 if (BO->getOpcode() == BO_Comma)
6177 return IsSpecialDiscardedValue(BO->getRHS());
6178 }
6179
Eli Friedmanc49c2262012-05-24 22:36:31 +00006180 // - conditional expression (5.16) where both the second and the third
Eli Friedmanf798f652012-05-24 22:04:19 +00006181 // operands are one of the above, or
6182 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
6183 return IsSpecialDiscardedValue(CO->getTrueExpr()) &&
6184 IsSpecialDiscardedValue(CO->getFalseExpr());
6185 // The related edge case of "*x ?: *x".
6186 if (BinaryConditionalOperator *BCO =
6187 dyn_cast<BinaryConditionalOperator>(E)) {
6188 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
6189 return IsSpecialDiscardedValue(OVE->getSourceExpr()) &&
6190 IsSpecialDiscardedValue(BCO->getFalseExpr());
6191 }
6192
6193 // Objective-C++ extensions to the rule.
6194 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
6195 return true;
6196
6197 return false;
6198}
6199
John McCall34376a62010-12-04 03:47:34 +00006200/// Perform the conversions required for an expression used in a
6201/// context that ignores the result.
John Wiegley01296292011-04-08 18:41:53 +00006202ExprResult Sema::IgnoredValueConversions(Expr *E) {
John McCall526ab472011-10-25 17:37:35 +00006203 if (E->hasPlaceholderType()) {
6204 ExprResult result = CheckPlaceholderExpr(E);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006205 if (result.isInvalid()) return E;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006206 E = result.get();
John McCall526ab472011-10-25 17:37:35 +00006207 }
6208
John McCallfee942d2010-12-02 02:07:15 +00006209 // C99 6.3.2.1:
6210 // [Except in specific positions,] an lvalue that does not have
6211 // array type is converted to the value stored in the
6212 // designated object (and is no longer an lvalue).
John McCalld68b2d02011-06-27 21:24:11 +00006213 if (E->isRValue()) {
6214 // In C, function designators (i.e. expressions of function type)
6215 // are r-values, but we still want to do function-to-pointer decay
6216 // on them. This is both technically correct and convenient for
6217 // some clients.
David Blaikiebbafb8a2012-03-11 07:00:24 +00006218 if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType())
John McCalld68b2d02011-06-27 21:24:11 +00006219 return DefaultFunctionArrayConversion(E);
6220
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006221 return E;
John McCalld68b2d02011-06-27 21:24:11 +00006222 }
John McCallfee942d2010-12-02 02:07:15 +00006223
Eli Friedmanf798f652012-05-24 22:04:19 +00006224 if (getLangOpts().CPlusPlus) {
6225 // The C++11 standard defines the notion of a discarded-value expression;
6226 // normally, we don't need to do anything to handle it, but if it is a
6227 // volatile lvalue with a special form, we perform an lvalue-to-rvalue
6228 // conversion.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006229 if (getLangOpts().CPlusPlus11 && E->isGLValue() &&
Eli Friedmanf798f652012-05-24 22:04:19 +00006230 E->getType().isVolatileQualified() &&
6231 IsSpecialDiscardedValue(E)) {
6232 ExprResult Res = DefaultLvalueConversion(E);
6233 if (Res.isInvalid())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006234 return E;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006235 E = Res.get();
Faisal Valia17d19f2013-11-07 05:17:06 +00006236 }
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006237 return E;
Eli Friedmanf798f652012-05-24 22:04:19 +00006238 }
John McCall34376a62010-12-04 03:47:34 +00006239
6240 // GCC seems to also exclude expressions of incomplete enum type.
6241 if (const EnumType *T = E->getType()->getAs<EnumType>()) {
6242 if (!T->getDecl()->isComplete()) {
6243 // FIXME: stupid workaround for a codegen bug!
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006244 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006245 return E;
John McCall34376a62010-12-04 03:47:34 +00006246 }
6247 }
6248
John Wiegley01296292011-04-08 18:41:53 +00006249 ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
6250 if (Res.isInvalid())
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006251 return E;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006252 E = Res.get();
John Wiegley01296292011-04-08 18:41:53 +00006253
John McCallca61b652010-12-04 12:29:11 +00006254 if (!E->getType()->isVoidType())
6255 RequireCompleteType(E->getExprLoc(), E->getType(),
6256 diag::err_incomplete_type);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006257 return E;
John McCall34376a62010-12-04 03:47:34 +00006258}
6259
Faisal Valia17d19f2013-11-07 05:17:06 +00006260// If we can unambiguously determine whether Var can never be used
6261// in a constant expression, return true.
6262// - if the variable and its initializer are non-dependent, then
6263// we can unambiguously check if the variable is a constant expression.
6264// - if the initializer is not value dependent - we can determine whether
6265// it can be used to initialize a constant expression. If Init can not
6266// be used to initialize a constant expression we conclude that Var can
6267// never be a constant expression.
6268// - FXIME: if the initializer is dependent, we can still do some analysis and
6269// identify certain cases unambiguously as non-const by using a Visitor:
6270// - such as those that involve odr-use of a ParmVarDecl, involve a new
6271// delete, lambda-expr, dynamic-cast, reinterpret-cast etc...
6272static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var,
6273 ASTContext &Context) {
6274 if (isa<ParmVarDecl>(Var)) return true;
Craig Topperc3ec1492014-05-26 06:22:03 +00006275 const VarDecl *DefVD = nullptr;
Faisal Valia17d19f2013-11-07 05:17:06 +00006276
6277 // If there is no initializer - this can not be a constant expression.
6278 if (!Var->getAnyInitializer(DefVD)) return true;
6279 assert(DefVD);
6280 if (DefVD->isWeak()) return false;
6281 EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
Richard Smithc941ba92014-02-06 23:35:16 +00006282
Faisal Valia17d19f2013-11-07 05:17:06 +00006283 Expr *Init = cast<Expr>(Eval->Value);
6284
6285 if (Var->getType()->isDependentType() || Init->isValueDependent()) {
Richard Smithc941ba92014-02-06 23:35:16 +00006286 // FIXME: Teach the constant evaluator to deal with the non-dependent parts
6287 // of value-dependent expressions, and use it here to determine whether the
6288 // initializer is a potential constant expression.
Faisal Valia17d19f2013-11-07 05:17:06 +00006289 return false;
Richard Smithc941ba92014-02-06 23:35:16 +00006290 }
6291
Faisal Valia17d19f2013-11-07 05:17:06 +00006292 return !IsVariableAConstantExpression(Var, Context);
6293}
6294
Faisal Valiab3d6462013-12-07 20:22:44 +00006295/// \brief Check if the current lambda has any potential captures
6296/// that must be captured by any of its enclosing lambdas that are ready to
6297/// capture. If there is a lambda that can capture a nested
6298/// potential-capture, go ahead and do so. Also, check to see if any
6299/// variables are uncaptureable or do not involve an odr-use so do not
6300/// need to be captured.
Faisal Valia17d19f2013-11-07 05:17:06 +00006301
Faisal Valiab3d6462013-12-07 20:22:44 +00006302static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(
6303 Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) {
6304
Faisal Valia17d19f2013-11-07 05:17:06 +00006305 assert(!S.isUnevaluatedContext());
6306 assert(S.CurContext->isDependentContext());
Faisal Valiab3d6462013-12-07 20:22:44 +00006307 assert(CurrentLSI->CallOperator == S.CurContext &&
6308 "The current call operator must be synchronized with Sema's CurContext");
6309
6310 const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent();
6311
6312 ArrayRef<const FunctionScopeInfo *> FunctionScopesArrayRef(
6313 S.FunctionScopes.data(), S.FunctionScopes.size());
6314
6315 // All the potentially captureable variables in the current nested
Faisal Valia17d19f2013-11-07 05:17:06 +00006316 // lambda (within a generic outer lambda), must be captured by an
6317 // outer lambda that is enclosed within a non-dependent context.
Faisal Valiab3d6462013-12-07 20:22:44 +00006318 const unsigned NumPotentialCaptures =
6319 CurrentLSI->getNumPotentialVariableCaptures();
6320 for (unsigned I = 0; I != NumPotentialCaptures; ++I) {
Craig Topperc3ec1492014-05-26 06:22:03 +00006321 Expr *VarExpr = nullptr;
6322 VarDecl *Var = nullptr;
Faisal Valia17d19f2013-11-07 05:17:06 +00006323 CurrentLSI->getPotentialVariableCapture(I, Var, VarExpr);
Faisal Valiab3d6462013-12-07 20:22:44 +00006324 // If the variable is clearly identified as non-odr-used and the full
6325 // expression is not instantiation dependent, only then do we not
6326 // need to check enclosing lambda's for speculative captures.
6327 // For e.g.:
6328 // Even though 'x' is not odr-used, it should be captured.
6329 // int test() {
6330 // const int x = 10;
6331 // auto L = [=](auto a) {
6332 // (void) +x + a;
6333 // };
6334 // }
6335 if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) &&
Faisal Valia17d19f2013-11-07 05:17:06 +00006336 !IsFullExprInstantiationDependent)
Faisal Valiab3d6462013-12-07 20:22:44 +00006337 continue;
6338
6339 // If we have a capture-capable lambda for the variable, go ahead and
6340 // capture the variable in that lambda (and all its enclosing lambdas).
6341 if (const Optional<unsigned> Index =
6342 getStackIndexOfNearestEnclosingCaptureCapableLambda(
6343 FunctionScopesArrayRef, Var, S)) {
6344 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
6345 MarkVarDeclODRUsed(Var, VarExpr->getExprLoc(), S,
6346 &FunctionScopeIndexOfCapturableLambda);
Faisal Valia17d19f2013-11-07 05:17:06 +00006347 }
6348 const bool IsVarNeverAConstantExpression =
6349 VariableCanNeverBeAConstantExpression(Var, S.Context);
6350 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
6351 // This full expression is not instantiation dependent or the variable
6352 // can not be used in a constant expression - which means
6353 // this variable must be odr-used here, so diagnose a
6354 // capture violation early, if the variable is un-captureable.
6355 // This is purely for diagnosing errors early. Otherwise, this
6356 // error would get diagnosed when the lambda becomes capture ready.
6357 QualType CaptureType, DeclRefType;
6358 SourceLocation ExprLoc = VarExpr->getExprLoc();
6359 if (S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
6360 /*EllipsisLoc*/ SourceLocation(),
6361 /*BuildAndDiagnose*/false, CaptureType,
Craig Topperc3ec1492014-05-26 06:22:03 +00006362 DeclRefType, nullptr)) {
Faisal Valia17d19f2013-11-07 05:17:06 +00006363 // We will never be able to capture this variable, and we need
6364 // to be able to in any and all instantiations, so diagnose it.
6365 S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
6366 /*EllipsisLoc*/ SourceLocation(),
6367 /*BuildAndDiagnose*/true, CaptureType,
Craig Topperc3ec1492014-05-26 06:22:03 +00006368 DeclRefType, nullptr);
Faisal Valia17d19f2013-11-07 05:17:06 +00006369 }
6370 }
6371 }
6372
Faisal Valiab3d6462013-12-07 20:22:44 +00006373 // Check if 'this' needs to be captured.
Faisal Valia17d19f2013-11-07 05:17:06 +00006374 if (CurrentLSI->hasPotentialThisCapture()) {
Faisal Valiab3d6462013-12-07 20:22:44 +00006375 // If we have a capture-capable lambda for 'this', go ahead and capture
6376 // 'this' in that lambda (and all its enclosing lambdas).
6377 if (const Optional<unsigned> Index =
6378 getStackIndexOfNearestEnclosingCaptureCapableLambda(
Craig Topperc3ec1492014-05-26 06:22:03 +00006379 FunctionScopesArrayRef, /*0 is 'this'*/ nullptr, S)) {
Faisal Valiab3d6462013-12-07 20:22:44 +00006380 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
6381 S.CheckCXXThisCapture(CurrentLSI->PotentialThisCaptureLocation,
6382 /*Explicit*/ false, /*BuildAndDiagnose*/ true,
6383 &FunctionScopeIndexOfCapturableLambda);
Faisal Valia17d19f2013-11-07 05:17:06 +00006384 }
6385 }
Faisal Valiab3d6462013-12-07 20:22:44 +00006386
6387 // Reset all the potential captures at the end of each full-expression.
Faisal Valia17d19f2013-11-07 05:17:06 +00006388 CurrentLSI->clearPotentialCaptures();
6389}
6390
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006391static ExprResult attemptRecovery(Sema &SemaRef,
6392 const TypoCorrectionConsumer &Consumer,
6393 TypoCorrection TC) {
6394 LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(),
6395 Consumer.getLookupResult().getLookupKind());
6396 const CXXScopeSpec *SS = Consumer.getSS();
6397 CXXScopeSpec NewSS;
6398
6399 // Use an approprate CXXScopeSpec for building the expr.
6400 if (auto *NNS = TC.getCorrectionSpecifier())
6401 NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange());
6402 else if (SS && !TC.WillReplaceSpecifier())
6403 NewSS = *SS;
6404
Richard Smithde6d6c42015-12-29 19:43:10 +00006405 if (auto *ND = TC.getFoundDecl()) {
Nick Lewycky01ad4ae2014-12-13 02:54:28 +00006406 R.setLookupName(ND->getDeclName());
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006407 R.addDecl(ND);
6408 if (ND->isCXXClassMember()) {
Nick Lewycky01ad4ae2014-12-13 02:54:28 +00006409 // Figure out the correct naming class to add to the LookupResult.
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006410 CXXRecordDecl *Record = nullptr;
6411 if (auto *NNS = TC.getCorrectionSpecifier())
6412 Record = NNS->getAsType()->getAsCXXRecordDecl();
6413 if (!Record)
Olivier Goffarted13fab2015-01-09 09:37:26 +00006414 Record =
6415 dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
6416 if (Record)
6417 R.setNamingClass(Record);
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006418
6419 // Detect and handle the case where the decl might be an implicit
6420 // member.
6421 bool MightBeImplicitMember;
6422 if (!Consumer.isAddressOfOperand())
6423 MightBeImplicitMember = true;
6424 else if (!NewSS.isEmpty())
6425 MightBeImplicitMember = false;
6426 else if (R.isOverloadedResult())
6427 MightBeImplicitMember = false;
6428 else if (R.isUnresolvableResult())
6429 MightBeImplicitMember = true;
6430 else
6431 MightBeImplicitMember = isa<FieldDecl>(ND) ||
6432 isa<IndirectFieldDecl>(ND) ||
6433 isa<MSPropertyDecl>(ND);
6434
6435 if (MightBeImplicitMember)
6436 return SemaRef.BuildPossibleImplicitMemberExpr(
6437 NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
Aaron Ballman6924dcd2015-09-01 14:49:24 +00006438 /*TemplateArgs*/ nullptr, /*S*/ nullptr);
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006439 } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
6440 return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
6441 Ivar->getIdentifier());
6442 }
6443 }
6444
Kaelyn Takata6f71ce22014-11-20 22:06:33 +00006445 return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
6446 /*AcceptInvalidDecl*/ true);
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006447}
6448
Kaelyn Takata6c759512014-10-27 18:07:37 +00006449namespace {
Kaelyn Takata57e07c92014-11-20 22:06:44 +00006450class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
6451 llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs;
6452
6453public:
6454 explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)
6455 : TypoExprs(TypoExprs) {}
6456 bool VisitTypoExpr(TypoExpr *TE) {
6457 TypoExprs.insert(TE);
6458 return true;
6459 }
6460};
6461
Kaelyn Takata6c759512014-10-27 18:07:37 +00006462class TransformTypos : public TreeTransform<TransformTypos> {
6463 typedef TreeTransform<TransformTypos> BaseTransform;
6464
Kaelyn Takatab8499f02015-05-05 19:17:03 +00006465 VarDecl *InitDecl; // A decl to avoid as a correction because it is in the
6466 // process of being initialized.
Kaelyn Takata49d84322014-11-11 23:26:56 +00006467 llvm::function_ref<ExprResult(Expr *)> ExprFilter;
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006468 llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs;
Kaelyn Takata6c759512014-10-27 18:07:37 +00006469 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006470 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
Kaelyn Takata6c759512014-10-27 18:07:37 +00006471
6472 /// \brief Emit diagnostics for all of the TypoExprs encountered.
6473 /// If the TypoExprs were successfully corrected, then the diagnostics should
6474 /// suggest the corrections. Otherwise the diagnostics will not suggest
6475 /// anything (having been passed an empty TypoCorrection).
6476 void EmitAllDiagnostics() {
6477 for (auto E : TypoExprs) {
6478 TypoExpr *TE = cast<TypoExpr>(E);
6479 auto &State = SemaRef.getTypoExprState(TE);
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006480 if (State.DiagHandler) {
6481 TypoCorrection TC = State.Consumer->getCurrentCorrection();
6482 ExprResult Replacement = TransformCache[TE];
6483
6484 // Extract the NamedDecl from the transformed TypoExpr and add it to the
6485 // TypoCorrection, replacing the existing decls. This ensures the right
6486 // NamedDecl is used in diagnostics e.g. in the case where overload
6487 // resolution was used to select one from several possible decls that
6488 // had been stored in the TypoCorrection.
6489 if (auto *ND = getDeclFromExpr(
6490 Replacement.isInvalid() ? nullptr : Replacement.get()))
6491 TC.setCorrectionDecl(ND);
6492
6493 State.DiagHandler(TC);
6494 }
Kaelyn Takata6c759512014-10-27 18:07:37 +00006495 SemaRef.clearDelayedTypo(TE);
6496 }
6497 }
6498
6499 /// \brief If corrections for the first TypoExpr have been exhausted for a
6500 /// given combination of the other TypoExprs, retry those corrections against
6501 /// the next combination of substitutions for the other TypoExprs by advancing
6502 /// to the next potential correction of the second TypoExpr. For the second
6503 /// and subsequent TypoExprs, if its stream of corrections has been exhausted,
6504 /// the stream is reset and the next TypoExpr's stream is advanced by one (a
6505 /// TypoExpr's correction stream is advanced by removing the TypoExpr from the
6506 /// TransformCache). Returns true if there is still any untried combinations
6507 /// of corrections.
6508 bool CheckAndAdvanceTypoExprCorrectionStreams() {
6509 for (auto TE : TypoExprs) {
6510 auto &State = SemaRef.getTypoExprState(TE);
6511 TransformCache.erase(TE);
6512 if (!State.Consumer->finished())
6513 return true;
6514 State.Consumer->resetCorrectionStream();
6515 }
6516 return false;
6517 }
6518
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006519 NamedDecl *getDeclFromExpr(Expr *E) {
6520 if (auto *OE = dyn_cast_or_null<OverloadExpr>(E))
6521 E = OverloadResolution[OE];
6522
6523 if (!E)
6524 return nullptr;
6525 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
Richard Smithde6d6c42015-12-29 19:43:10 +00006526 return DRE->getFoundDecl();
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006527 if (auto *ME = dyn_cast<MemberExpr>(E))
Richard Smithde6d6c42015-12-29 19:43:10 +00006528 return ME->getFoundDecl();
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006529 // FIXME: Add any other expr types that could be be seen by the delayed typo
6530 // correction TreeTransform for which the corresponding TypoCorrection could
Nick Lewycky39f9dbc2014-12-16 21:48:39 +00006531 // contain multiple decls.
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006532 return nullptr;
6533 }
6534
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006535 ExprResult TryTransform(Expr *E) {
6536 Sema::SFINAETrap Trap(SemaRef);
6537 ExprResult Res = TransformExpr(E);
6538 if (Trap.hasErrorOccurred() || Res.isInvalid())
6539 return ExprError();
6540
6541 return ExprFilter(Res.get());
6542 }
6543
Kaelyn Takata6c759512014-10-27 18:07:37 +00006544public:
Kaelyn Takatab8499f02015-05-05 19:17:03 +00006545 TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter)
6546 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
Kaelyn Takata6c759512014-10-27 18:07:37 +00006547
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006548 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
6549 MultiExprArg Args,
6550 SourceLocation RParenLoc,
6551 Expr *ExecConfig = nullptr) {
6552 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
6553 RParenLoc, ExecConfig);
6554 if (auto *OE = dyn_cast<OverloadExpr>(Callee)) {
Reid Klecknera9e65ba2014-12-13 01:11:23 +00006555 if (Result.isUsable()) {
Reid Klecknera7fe33e2014-12-13 00:53:10 +00006556 Expr *ResultCall = Result.get();
6557 if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
6558 ResultCall = BE->getSubExpr();
6559 if (auto *CE = dyn_cast<CallExpr>(ResultCall))
6560 OverloadResolution[OE] = CE->getCallee();
6561 }
Kaelyn Takatafe408a72014-10-27 18:07:46 +00006562 }
6563 return Result;
6564 }
6565
Kaelyn Takata6c759512014-10-27 18:07:37 +00006566 ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); }
6567
Saleem Abdulrasoola1742412015-10-31 00:39:15 +00006568 ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); }
6569
Kaelyn Takata6c759512014-10-27 18:07:37 +00006570 ExprResult Transform(Expr *E) {
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006571 ExprResult Res;
Kaelyn Takata6c759512014-10-27 18:07:37 +00006572 while (true) {
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006573 Res = TryTransform(E);
Kaelyn Takata49d84322014-11-11 23:26:56 +00006574
Kaelyn Takata6c759512014-10-27 18:07:37 +00006575 // Exit if either the transform was valid or if there were no TypoExprs
6576 // to transform that still have any untried correction candidates..
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006577 if (!Res.isInvalid() ||
Kaelyn Takata6c759512014-10-27 18:07:37 +00006578 !CheckAndAdvanceTypoExprCorrectionStreams())
6579 break;
6580 }
6581
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006582 // Ensure none of the TypoExprs have multiple typo correction candidates
6583 // with the same edit length that pass all the checks and filters.
6584 // TODO: Properly handle various permutations of possible corrections when
6585 // there is more than one potentially ambiguous typo correction.
Kaelyn Takata26ffc5f2015-06-25 23:47:39 +00006586 // Also, disable typo correction while attempting the transform when
6587 // handling potentially ambiguous typo corrections as any new TypoExprs will
6588 // have been introduced by the application of one of the correction
6589 // candidates and add little to no value if corrected.
6590 SemaRef.DisableTypoCorrection = true;
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006591 while (!AmbiguousTypoExprs.empty()) {
6592 auto TE = AmbiguousTypoExprs.back();
6593 auto Cached = TransformCache[TE];
Kaelyn Takata7a503692015-01-27 22:01:39 +00006594 auto &State = SemaRef.getTypoExprState(TE);
6595 State.Consumer->saveCurrentPosition();
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006596 TransformCache.erase(TE);
6597 if (!TryTransform(E).isInvalid()) {
Kaelyn Takata7a503692015-01-27 22:01:39 +00006598 State.Consumer->resetCorrectionStream();
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006599 TransformCache.erase(TE);
6600 Res = ExprError();
6601 break;
Kaelyn Takata7a503692015-01-27 22:01:39 +00006602 }
6603 AmbiguousTypoExprs.remove(TE);
6604 State.Consumer->restoreSavedPosition();
6605 TransformCache[TE] = Cached;
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006606 }
Kaelyn Takata26ffc5f2015-06-25 23:47:39 +00006607 SemaRef.DisableTypoCorrection = false;
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006608
Kaelyn Takata57e07c92014-11-20 22:06:44 +00006609 // Ensure that all of the TypoExprs within the current Expr have been found.
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006610 if (!Res.isUsable())
Kaelyn Takata57e07c92014-11-20 22:06:44 +00006611 FindTypoExprs(TypoExprs).TraverseStmt(E);
6612
Kaelyn Takata6c759512014-10-27 18:07:37 +00006613 EmitAllDiagnostics();
6614
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006615 return Res;
Kaelyn Takata6c759512014-10-27 18:07:37 +00006616 }
6617
6618 ExprResult TransformTypoExpr(TypoExpr *E) {
6619 // If the TypoExpr hasn't been seen before, record it. Otherwise, return the
6620 // cached transformation result if there is one and the TypoExpr isn't the
6621 // first one that was encountered.
6622 auto &CacheEntry = TransformCache[E];
6623 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
6624 return CacheEntry;
6625 }
6626
6627 auto &State = SemaRef.getTypoExprState(E);
6628 assert(State.Consumer && "Cannot transform a cleared TypoExpr");
6629
6630 // For the first TypoExpr and an uncached TypoExpr, find the next likely
6631 // typo correction and return it.
6632 while (TypoCorrection TC = State.Consumer->getNextCorrection()) {
Richard Smithde6d6c42015-12-29 19:43:10 +00006633 if (InitDecl && TC.getFoundDecl() == InitDecl)
Kaelyn Takatab8499f02015-05-05 19:17:03 +00006634 continue;
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006635 ExprResult NE = State.RecoveryHandler ?
6636 State.RecoveryHandler(SemaRef, E, TC) :
6637 attemptRecovery(SemaRef, *State.Consumer, TC);
6638 if (!NE.isInvalid()) {
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006639 // Check whether there may be a second viable correction with the same
6640 // edit distance; if so, remember this TypoExpr may have an ambiguous
6641 // correction so it can be more thoroughly vetted later.
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006642 TypoCorrection Next;
Kaelyn Takata5ca2ecd2014-11-21 18:47:58 +00006643 if ((Next = State.Consumer->peekNextCorrection()) &&
6644 Next.getEditDistance(false) == TC.getEditDistance(false)) {
6645 AmbiguousTypoExprs.insert(E);
6646 } else {
6647 AmbiguousTypoExprs.remove(E);
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006648 }
6649 assert(!NE.isUnset() &&
6650 "Typo was transformed into a valid-but-null ExprResult");
Kaelyn Takata6c759512014-10-27 18:07:37 +00006651 return CacheEntry = NE;
Kaelyn Takata3f9794f2014-11-20 22:06:30 +00006652 }
Kaelyn Takata6c759512014-10-27 18:07:37 +00006653 }
6654 return CacheEntry = ExprError();
6655 }
6656};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00006657}
Faisal Valia17d19f2013-11-07 05:17:06 +00006658
Kaelyn Takatab8499f02015-05-05 19:17:03 +00006659ExprResult
6660Sema::CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl,
6661 llvm::function_ref<ExprResult(Expr *)> Filter) {
Kaelyn Takata49d84322014-11-11 23:26:56 +00006662 // If the current evaluation context indicates there are uncorrected typos
6663 // and the current expression isn't guaranteed to not have typos, try to
6664 // resolve any TypoExpr nodes that might be in the expression.
Kaelyn Takatac71dda22014-12-02 22:05:35 +00006665 if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&
Kaelyn Takata49d84322014-11-11 23:26:56 +00006666 (E->isTypeDependent() || E->isValueDependent() ||
6667 E->isInstantiationDependent())) {
Kaelyn Takatac49838b2015-01-28 21:10:46 +00006668 auto TyposInContext = ExprEvalContexts.back().NumTypos;
6669 assert(TyposInContext < ~0U && "Recursive call of CorrectDelayedTyposInExpr");
6670 ExprEvalContexts.back().NumTypos = ~0U;
Kaelyn Takata49d84322014-11-11 23:26:56 +00006671 auto TyposResolved = DelayedTypos.size();
Kaelyn Takatab8499f02015-05-05 19:17:03 +00006672 auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E);
Kaelyn Takatac49838b2015-01-28 21:10:46 +00006673 ExprEvalContexts.back().NumTypos = TyposInContext;
Kaelyn Takata49d84322014-11-11 23:26:56 +00006674 TyposResolved -= DelayedTypos.size();
Nick Lewycky4d59b772014-12-16 22:02:06 +00006675 if (Result.isInvalid() || Result.get() != E) {
Kaelyn Takata49d84322014-11-11 23:26:56 +00006676 ExprEvalContexts.back().NumTypos -= TyposResolved;
6677 return Result;
6678 }
Nick Lewycky4d59b772014-12-16 22:02:06 +00006679 assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
Kaelyn Takata49d84322014-11-11 23:26:56 +00006680 }
6681 return E;
6682}
6683
Richard Smith945f8d32013-01-14 22:39:08 +00006684ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
Fariborz Jahaniane735ff92013-01-24 22:11:45 +00006685 bool DiscardedValue,
Faisal Vali5fb7c3c2013-12-05 01:40:41 +00006686 bool IsConstexpr,
6687 bool IsLambdaInitCaptureInitializer) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006688 ExprResult FullExpr = FE;
John Wiegley01296292011-04-08 18:41:53 +00006689
6690 if (!FullExpr.get())
Douglas Gregora6e053e2010-12-15 01:34:56 +00006691 return ExprError();
Faisal Vali5fb7c3c2013-12-05 01:40:41 +00006692
6693 // If we are an init-expression in a lambdas init-capture, we should not
6694 // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
6695 // containing full-expression is done).
6696 // template<class ... Ts> void test(Ts ... t) {
6697 // test([&a(t)]() { <-- (t) is an init-expr that shouldn't be diagnosed now.
6698 // return a;
6699 // }() ...);
6700 // }
6701 // FIXME: This is a hack. It would be better if we pushed the lambda scope
6702 // when we parse the lambda introducer, and teach capturing (but not
6703 // unexpanded pack detection) to walk over LambdaScopeInfos which don't have a
6704 // corresponding class yet (that is, have LambdaScopeInfo either represent a
6705 // lambda where we've entered the introducer but not the body, or represent a
6706 // lambda where we've entered the body, depending on where the
6707 // parser/instantiation has got to).
6708 if (!IsLambdaInitCaptureInitializer &&
6709 DiagnoseUnexpandedParameterPack(FullExpr.get()))
Douglas Gregor506bd562010-12-13 22:49:22 +00006710 return ExprError();
6711
Douglas Gregorb5af2e92013-03-07 22:57:58 +00006712 // Top-level expressions default to 'id' when we're in a debugger.
Richard Smith945f8d32013-01-14 22:39:08 +00006713 if (DiscardedValue && getLangOpts().DebuggerCastResultToId &&
Douglas Gregorb5af2e92013-03-07 22:57:58 +00006714 FullExpr.get()->getType() == Context.UnknownAnyTy) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006715 FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType());
Douglas Gregor95715f92011-12-15 00:53:32 +00006716 if (FullExpr.isInvalid())
6717 return ExprError();
6718 }
Douglas Gregor0ec210b2011-03-07 02:05:23 +00006719
Richard Smith945f8d32013-01-14 22:39:08 +00006720 if (DiscardedValue) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006721 FullExpr = CheckPlaceholderExpr(FullExpr.get());
Richard Smith945f8d32013-01-14 22:39:08 +00006722 if (FullExpr.isInvalid())
6723 return ExprError();
6724
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006725 FullExpr = IgnoredValueConversions(FullExpr.get());
Richard Smith945f8d32013-01-14 22:39:08 +00006726 if (FullExpr.isInvalid())
6727 return ExprError();
6728 }
John Wiegley01296292011-04-08 18:41:53 +00006729
Kaelyn Takata49d84322014-11-11 23:26:56 +00006730 FullExpr = CorrectDelayedTyposInExpr(FullExpr.get());
6731 if (FullExpr.isInvalid())
6732 return ExprError();
Kaelyn Takata6c759512014-10-27 18:07:37 +00006733
Fariborz Jahaniane735ff92013-01-24 22:11:45 +00006734 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
Faisal Valia17d19f2013-11-07 05:17:06 +00006735
Faisal Vali218e94b2013-11-12 03:56:08 +00006736 // At the end of this full expression (which could be a deeply nested
6737 // lambda), if there is a potential capture within the nested lambda,
6738 // have the outer capture-able lambda try and capture it.
Faisal Valia17d19f2013-11-07 05:17:06 +00006739 // Consider the following code:
6740 // void f(int, int);
6741 // void f(const int&, double);
6742 // void foo() {
6743 // const int x = 10, y = 20;
6744 // auto L = [=](auto a) {
6745 // auto M = [=](auto b) {
6746 // f(x, b); <-- requires x to be captured by L and M
6747 // f(y, a); <-- requires y to be captured by L, but not all Ms
6748 // };
6749 // };
6750 // }
6751
6752 // FIXME: Also consider what happens for something like this that involves
6753 // the gnu-extension statement-expressions or even lambda-init-captures:
6754 // void f() {
6755 // const int n = 0;
6756 // auto L = [&](auto a) {
6757 // +n + ({ 0; a; });
6758 // };
6759 // }
6760 //
Faisal Vali218e94b2013-11-12 03:56:08 +00006761 // Here, we see +n, and then the full-expression 0; ends, so we don't
6762 // capture n (and instead remove it from our list of potential captures),
6763 // and then the full-expression +n + ({ 0; }); ends, but it's too late
6764 // for us to see that we need to capture n after all.
Faisal Valia17d19f2013-11-07 05:17:06 +00006765
Faisal Vali8bc2bc72013-11-12 03:48:27 +00006766 LambdaScopeInfo *const CurrentLSI = getCurLambda();
6767 // FIXME: PR 17877 showed that getCurLambda() can return a valid pointer
6768 // even if CurContext is not a lambda call operator. Refer to that Bug Report
6769 // for an example of the code that might cause this asynchrony.
6770 // By ensuring we are in the context of a lambda's call operator
6771 // we can fix the bug (we only need to check whether we need to capture
6772 // if we are within a lambda's body); but per the comments in that
6773 // PR, a proper fix would entail :
6774 // "Alternative suggestion:
6775 // - Add to Sema an integer holding the smallest (outermost) scope
6776 // index that we are *lexically* within, and save/restore/set to
6777 // FunctionScopes.size() in InstantiatingTemplate's
6778 // constructor/destructor.
6779 // - Teach the handful of places that iterate over FunctionScopes to
Faisal Valiab3d6462013-12-07 20:22:44 +00006780 // stop at the outermost enclosing lexical scope."
6781 const bool IsInLambdaDeclContext = isLambdaCallOperator(CurContext);
6782 if (IsInLambdaDeclContext && CurrentLSI &&
Faisal Vali8bc2bc72013-11-12 03:48:27 +00006783 CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
Faisal Valiab3d6462013-12-07 20:22:44 +00006784 CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(FE, CurrentLSI,
6785 *this);
John McCall5d413782010-12-06 08:20:24 +00006786 return MaybeCreateExprWithCleanups(FullExpr);
Anders Carlsson85a307d2009-05-17 18:41:29 +00006787}
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00006788
6789StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
6790 if (!FullStmt) return StmtError();
6791
John McCall5d413782010-12-06 08:20:24 +00006792 return MaybeCreateStmtWithCleanups(FullStmt);
Argyrios Kyrtzidis3050d9b2010-11-02 02:33:08 +00006793}
Francois Pichet4a7de3e2011-05-06 20:48:22 +00006794
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006795Sema::IfExistsResult
6796Sema::CheckMicrosoftIfExistsSymbol(Scope *S,
6797 CXXScopeSpec &SS,
6798 const DeclarationNameInfo &TargetNameInfo) {
Francois Pichet4a7de3e2011-05-06 20:48:22 +00006799 DeclarationName TargetName = TargetNameInfo.getName();
6800 if (!TargetName)
Douglas Gregor43edb322011-10-24 22:31:10 +00006801 return IER_DoesNotExist;
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006802
Douglas Gregor43edb322011-10-24 22:31:10 +00006803 // If the name itself is dependent, then the result is dependent.
6804 if (TargetName.isDependentName())
6805 return IER_Dependent;
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006806
Francois Pichet4a7de3e2011-05-06 20:48:22 +00006807 // Do the redeclaration lookup in the current scope.
6808 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
6809 Sema::NotForRedeclaration);
Douglas Gregor43edb322011-10-24 22:31:10 +00006810 LookupParsedName(R, S, &SS);
Francois Pichet4a7de3e2011-05-06 20:48:22 +00006811 R.suppressDiagnostics();
Douglas Gregor43edb322011-10-24 22:31:10 +00006812
6813 switch (R.getResultKind()) {
6814 case LookupResult::Found:
6815 case LookupResult::FoundOverloaded:
6816 case LookupResult::FoundUnresolvedValue:
6817 case LookupResult::Ambiguous:
6818 return IER_Exists;
6819
6820 case LookupResult::NotFound:
6821 return IER_DoesNotExist;
6822
6823 case LookupResult::NotFoundInCurrentInstantiation:
6824 return IER_Dependent;
6825 }
David Blaikie8a40f702012-01-17 06:56:22 +00006826
6827 llvm_unreachable("Invalid LookupResult Kind!");
Francois Pichet4a7de3e2011-05-06 20:48:22 +00006828}
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006829
Douglas Gregor4a2a8f72011-10-25 03:44:56 +00006830Sema::IfExistsResult
6831Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
6832 bool IsIfExists, CXXScopeSpec &SS,
6833 UnqualifiedId &Name) {
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006834 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
Douglas Gregor4a2a8f72011-10-25 03:44:56 +00006835
6836 // Check for unexpanded parameter packs.
6837 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
6838 collectUnexpandedParameterPacks(SS, Unexpanded);
6839 collectUnexpandedParameterPacks(TargetNameInfo, Unexpanded);
6840 if (!Unexpanded.empty()) {
6841 DiagnoseUnexpandedParameterPacks(KeywordLoc,
6842 IsIfExists? UPPC_IfExists
6843 : UPPC_IfNotExists,
6844 Unexpanded);
6845 return IER_Error;
6846 }
6847
Douglas Gregordeb4a2be2011-10-25 01:33:02 +00006848 return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
6849}