blob: 7e35ab3eb05b7fad04cfb688578ce097c1995d7c [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
James Dennett306f1792012-06-22 05:14:59 +00009///
10/// \file
11/// \brief Implements semantic analysis for C++ expressions.
12///
13//===----------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +000014
John McCall2d887082010-08-25 22:03:47 +000015#include "clang/Sema/SemaInternal.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000016#include "TypeLocBuilder.h"
Steve Naroff210679c2007-08-25 14:02:58 +000017#include "clang/AST/ASTContext.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000018#include "clang/AST/CXXInheritance.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000019#include "clang/AST/CharUnits.h"
John McCall7cd088e2010-08-24 07:21:54 +000020#include "clang/AST/DeclObjC.h"
Richard Smith6c3af3d2013-01-17 01:17:56 +000021#include "clang/AST/EvaluatedExprVisitor.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000022#include "clang/AST/ExprCXX.h"
Fariborz Jahaniand4266622010-06-16 18:56:04 +000023#include "clang/AST/ExprObjC.h"
Douglas Gregorb57fb492010-02-24 22:38:50 +000024#include "clang/AST/TypeLoc.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000025#include "clang/Basic/PartialDiagnostic.h"
Sebastian Redlb5a57a62008-12-03 20:26:15 +000026#include "clang/Basic/TargetInfo.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000027#include "clang/Lex/Preprocessor.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000028#include "clang/Sema/DeclSpec.h"
29#include "clang/Sema/Initialization.h"
30#include "clang/Sema/Lookup.h"
31#include "clang/Sema/ParsedTemplate.h"
32#include "clang/Sema/Scope.h"
33#include "clang/Sema/ScopeInfo.h"
34#include "clang/Sema/TemplateDeduction.h"
Sebastian Redlbd45d252012-02-16 12:59:47 +000035#include "llvm/ADT/APInt.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000036#include "llvm/ADT/STLExtras.h"
Chandler Carruth73e0a912011-05-01 07:23:17 +000037#include "llvm/Support/ErrorHandling.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000038using namespace clang;
John McCall2a7fb272010-08-25 05:32:35 +000039using namespace sema;
Reid Spencer5f016e22007-07-11 17:01:13 +000040
Richard Smith2db075b2013-03-26 01:15:19 +000041/// \brief Handle the result of the special case name lookup for inheriting
42/// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
43/// constructor names in member using declarations, even if 'X' is not the
44/// name of the corresponding type.
45ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,
46 SourceLocation NameLoc,
47 IdentifierInfo &Name) {
48 NestedNameSpecifier *NNS = SS.getScopeRep();
49
50 // Convert the nested-name-specifier into a type.
51 QualType Type;
52 switch (NNS->getKind()) {
53 case NestedNameSpecifier::TypeSpec:
54 case NestedNameSpecifier::TypeSpecWithTemplate:
55 Type = QualType(NNS->getAsType(), 0);
56 break;
57
58 case NestedNameSpecifier::Identifier:
59 // Strip off the last layer of the nested-name-specifier and build a
60 // typename type for it.
61 assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
62 Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
63 NNS->getAsIdentifier());
64 break;
65
66 case NestedNameSpecifier::Global:
67 case NestedNameSpecifier::Namespace:
68 case NestedNameSpecifier::NamespaceAlias:
69 llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
70 }
71
72 // This reference to the type is located entirely at the location of the
73 // final identifier in the qualified-id.
74 return CreateParsedType(Type,
75 Context.getTrivialTypeSourceInfo(Type, NameLoc));
76}
77
John McCallb3d87482010-08-24 05:47:05 +000078ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000079 IdentifierInfo &II,
John McCallb3d87482010-08-24 05:47:05 +000080 SourceLocation NameLoc,
81 Scope *S, CXXScopeSpec &SS,
82 ParsedType ObjectTypePtr,
83 bool EnteringContext) {
Douglas Gregor124b8782010-02-16 19:09:40 +000084 // Determine where to perform name lookup.
85
86 // FIXME: This area of the standard is very messy, and the current
87 // wording is rather unclear about which scopes we search for the
88 // destructor name; see core issues 399 and 555. Issue 399 in
89 // particular shows where the current description of destructor name
90 // lookup is completely out of line with existing practice, e.g.,
91 // this appears to be ill-formed:
92 //
93 // namespace N {
94 // template <typename T> struct S {
95 // ~S();
96 // };
97 // }
98 //
99 // void f(N::S<int>* s) {
100 // s->N::S<int>::~S();
101 // }
102 //
Douglas Gregor93649fd2010-02-23 00:15:22 +0000103 // See also PR6358 and PR6359.
Sebastian Redlc0fee502010-07-07 23:17:38 +0000104 // For this reason, we're currently only doing the C++03 version of this
105 // code; the C++0x version has to wait until we get a proper spec.
Douglas Gregor124b8782010-02-16 19:09:40 +0000106 QualType SearchType;
107 DeclContext *LookupCtx = 0;
108 bool isDependent = false;
109 bool LookInScope = false;
110
111 // If we have an object type, it's because we are in a
112 // pseudo-destructor-expression or a member access expression, and
113 // we know what type we're looking for.
114 if (ObjectTypePtr)
115 SearchType = GetTypeFromParser(ObjectTypePtr);
116
117 if (SS.isSet()) {
Douglas Gregor93649fd2010-02-23 00:15:22 +0000118 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000119
Douglas Gregor93649fd2010-02-23 00:15:22 +0000120 bool AlreadySearched = false;
121 bool LookAtPrefix = true;
Sebastian Redlc0fee502010-07-07 23:17:38 +0000122 // C++ [basic.lookup.qual]p6:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000123 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
Sebastian Redlc0fee502010-07-07 23:17:38 +0000124 // the type-names are looked up as types in the scope designated by the
125 // nested-name-specifier. In a qualified-id of the form:
NAKAMURA Takumi00995302011-01-27 07:09:49 +0000126 //
127 // ::[opt] nested-name-specifier ~ class-name
Sebastian Redlc0fee502010-07-07 23:17:38 +0000128 //
129 // where the nested-name-specifier designates a namespace scope, and in
Chandler Carruth5e895a82010-02-21 10:19:54 +0000130 // a qualified-id of the form:
Douglas Gregor124b8782010-02-16 19:09:40 +0000131 //
NAKAMURA Takumi00995302011-01-27 07:09:49 +0000132 // ::opt nested-name-specifier class-name :: ~ class-name
Douglas Gregor124b8782010-02-16 19:09:40 +0000133 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000134 // the class-names are looked up as types in the scope designated by
Sebastian Redlc0fee502010-07-07 23:17:38 +0000135 // the nested-name-specifier.
Douglas Gregor124b8782010-02-16 19:09:40 +0000136 //
Sebastian Redlc0fee502010-07-07 23:17:38 +0000137 // Here, we check the first case (completely) and determine whether the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000138 // code below is permitted to look at the prefix of the
Sebastian Redlc0fee502010-07-07 23:17:38 +0000139 // nested-name-specifier.
140 DeclContext *DC = computeDeclContext(SS, EnteringContext);
141 if (DC && DC->isFileContext()) {
142 AlreadySearched = true;
143 LookupCtx = DC;
144 isDependent = false;
145 } else if (DC && isa<CXXRecordDecl>(DC))
146 LookAtPrefix = false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000147
Sebastian Redlc0fee502010-07-07 23:17:38 +0000148 // The second case from the C++03 rules quoted further above.
Douglas Gregor93649fd2010-02-23 00:15:22 +0000149 NestedNameSpecifier *Prefix = 0;
150 if (AlreadySearched) {
151 // Nothing left to do.
152 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
153 CXXScopeSpec PrefixSS;
Douglas Gregor7e384942011-02-25 16:07:42 +0000154 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
Douglas Gregor93649fd2010-02-23 00:15:22 +0000155 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
156 isDependent = isDependentScopeSpecifier(PrefixSS);
Douglas Gregor93649fd2010-02-23 00:15:22 +0000157 } else if (ObjectTypePtr) {
Douglas Gregor124b8782010-02-16 19:09:40 +0000158 LookupCtx = computeDeclContext(SearchType);
159 isDependent = SearchType->isDependentType();
160 } else {
161 LookupCtx = computeDeclContext(SS, EnteringContext);
Douglas Gregor93649fd2010-02-23 00:15:22 +0000162 isDependent = LookupCtx && LookupCtx->isDependentContext();
Douglas Gregor124b8782010-02-16 19:09:40 +0000163 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000164
Douglas Gregoredc90502010-02-25 04:46:04 +0000165 LookInScope = false;
Douglas Gregor124b8782010-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 Takumidfbb02a2011-01-27 07:10:08 +0000176 assert((isDependent || !SearchType->isIncompleteType()) &&
Douglas Gregor124b8782010-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
Douglas Gregor7ec18732011-03-04 22:32:08 +0000185 TypeDecl *NonMatchingTypeDecl = 0;
Douglas Gregor124b8782010-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 Gregor7ec18732011-03-04 22:32:08 +0000189 // have one) and, if that fails to find a match, in the scope (if
Douglas Gregor124b8782010-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 Gregora2e7dd22010-02-25 01:56:36 +0000194 else if (Step == 1 && LookInScope && S)
Douglas Gregor124b8782010-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 McCallb3d87482010-08-24 05:47:05 +0000201 return ParsedType();
Douglas Gregor124b8782010-02-16 19:09:40 +0000202
203 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
204 QualType T = Context.getTypeDeclType(Type);
Douglas Gregor124b8782010-02-16 19:09:40 +0000205
206 if (SearchType.isNull() || SearchType->isDependentType() ||
207 Context.hasSameUnqualifiedType(T, SearchType)) {
208 // We found our type!
209
John McCallb3d87482010-08-24 05:47:05 +0000210 return ParsedType::make(T);
Douglas Gregor124b8782010-02-16 19:09:40 +0000211 }
John Wiegley36784e72011-03-08 08:13:22 +0000212
Douglas Gregor7ec18732011-03-04 22:32:08 +0000213 if (!SearchType.isNull())
214 NonMatchingTypeDecl = Type;
Douglas Gregor124b8782010-02-16 19:09:40 +0000215 }
216
217 // If the name that we found is a class template name, and it is
218 // the same name as the template name in the last part of the
219 // nested-name-specifier (if present) or the object type, then
220 // this is the destructor for that class.
221 // FIXME: This is a workaround until we get real drafting for core
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000222 // issue 399, for which there isn't even an obvious direction.
Douglas Gregor124b8782010-02-16 19:09:40 +0000223 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
224 QualType MemberOfType;
225 if (SS.isSet()) {
226 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
227 // Figure out the type of the context, if it has one.
John McCall3cb0ebd2010-03-10 03:28:59 +0000228 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
229 MemberOfType = Context.getTypeDeclType(Record);
Douglas Gregor124b8782010-02-16 19:09:40 +0000230 }
231 }
232 if (MemberOfType.isNull())
233 MemberOfType = SearchType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000234
Douglas Gregor124b8782010-02-16 19:09:40 +0000235 if (MemberOfType.isNull())
236 continue;
237
238 // We're referring into a class template specialization. If the
239 // class template we found is the same as the template being
240 // specialized, we found what we are looking for.
241 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
242 if (ClassTemplateSpecializationDecl *Spec
243 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
244 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
245 Template->getCanonicalDecl())
John McCallb3d87482010-08-24 05:47:05 +0000246 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000247 }
248
249 continue;
250 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000251
Douglas Gregor124b8782010-02-16 19:09:40 +0000252 // We're referring to an unresolved class template
253 // specialization. Determine whether we class template we found
254 // is the same as the template being specialized or, if we don't
255 // know which template is being specialized, that it at least
256 // has the same name.
257 if (const TemplateSpecializationType *SpecType
258 = MemberOfType->getAs<TemplateSpecializationType>()) {
259 TemplateName SpecName = SpecType->getTemplateName();
260
261 // The class template we found is the same template being
262 // specialized.
263 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
264 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
John McCallb3d87482010-08-24 05:47:05 +0000265 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000266
267 continue;
268 }
269
270 // The class template we found has the same name as the
271 // (dependent) template name being specialized.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000272 if (DependentTemplateName *DepTemplate
Douglas Gregor124b8782010-02-16 19:09:40 +0000273 = SpecName.getAsDependentTemplateName()) {
274 if (DepTemplate->isIdentifier() &&
275 DepTemplate->getIdentifier() == Template->getIdentifier())
John McCallb3d87482010-08-24 05:47:05 +0000276 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000277
278 continue;
279 }
280 }
281 }
282 }
283
284 if (isDependent) {
285 // We didn't find our type, but that's okay: it's dependent
286 // anyway.
Douglas Gregore29425b2011-02-28 22:42:13 +0000287
288 // FIXME: What if we have no nested-name-specifier?
289 QualType T = CheckTypenameType(ETK_None, SourceLocation(),
290 SS.getWithLocInContext(Context),
291 II, NameLoc);
John McCallb3d87482010-08-24 05:47:05 +0000292 return ParsedType::make(T);
Douglas Gregor124b8782010-02-16 19:09:40 +0000293 }
294
Douglas Gregor7ec18732011-03-04 22:32:08 +0000295 if (NonMatchingTypeDecl) {
296 QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
297 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
298 << T << SearchType;
299 Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
300 << T;
301 } else if (ObjectTypePtr)
302 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000303 << &II;
David Blaikie36771d92013-03-20 17:42:13 +0000304 else {
305 SemaDiagnosticBuilder DtorDiag = Diag(NameLoc,
306 diag::err_destructor_class_name);
307 if (S) {
308 const DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity());
309 if (const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
310 DtorDiag << FixItHint::CreateReplacement(SourceRange(NameLoc),
311 Class->getNameAsString());
312 }
313 }
Douglas Gregor124b8782010-02-16 19:09:40 +0000314
John McCallb3d87482010-08-24 05:47:05 +0000315 return ParsedType();
Douglas Gregor124b8782010-02-16 19:09:40 +0000316}
317
David Blaikie53a75c02011-12-08 16:13:53 +0000318ParsedType Sema::getDestructorType(const DeclSpec& DS, ParsedType ObjectType) {
David Blaikie4db8c442011-12-12 04:13:55 +0000319 if (DS.getTypeSpecType() == DeclSpec::TST_error || !ObjectType)
David Blaikie53a75c02011-12-08 16:13:53 +0000320 return ParsedType();
321 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype
322 && "only get destructor types from declspecs");
323 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
324 QualType SearchType = GetTypeFromParser(ObjectType);
325 if (SearchType->isDependentType() || Context.hasSameUnqualifiedType(SearchType, T)) {
326 return ParsedType::make(T);
327 }
328
329 Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
330 << T << SearchType;
331 return ParsedType();
332}
333
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000334/// \brief Build a C++ typeid expression with a type operand.
John McCall60d7b3a2010-08-24 06:29:42 +0000335ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000336 SourceLocation TypeidLoc,
337 TypeSourceInfo *Operand,
338 SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000339 // C++ [expr.typeid]p4:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000340 // The top-level cv-qualifiers of the lvalue expression or the type-id
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000341 // that is the operand of typeid are always ignored.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000342 // If the type of the type-id is a class type or a reference to a class
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000343 // type, the class shall be completely-defined.
Douglas Gregord1c1d7b2010-06-02 06:16:02 +0000344 Qualifiers Quals;
345 QualType T
346 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
347 Quals);
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000348 if (T->getAs<RecordType>() &&
349 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
350 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000351
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000352 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
353 Operand,
354 SourceRange(TypeidLoc, RParenLoc)));
355}
356
357/// \brief Build a C++ typeid expression with an expression operand.
John McCall60d7b3a2010-08-24 06:29:42 +0000358ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000359 SourceLocation TypeidLoc,
360 Expr *E,
361 SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000362 if (E && !E->isTypeDependent()) {
John McCall6dbba4f2011-10-11 23:14:30 +0000363 if (E->getType()->isPlaceholderType()) {
364 ExprResult result = CheckPlaceholderExpr(E);
365 if (result.isInvalid()) return ExprError();
366 E = result.take();
367 }
368
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000369 QualType T = E->getType();
370 if (const RecordType *RecordT = T->getAs<RecordType>()) {
371 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
372 // C++ [expr.typeid]p3:
373 // [...] If the type of the expression is a class type, the class
374 // shall be completely-defined.
375 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
376 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000377
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000378 // C++ [expr.typeid]p3:
Sebastian Redl906082e2010-07-20 04:20:21 +0000379 // When typeid is applied to an expression other than an glvalue of a
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000380 // polymorphic class type [...] [the] expression is an unevaluated
381 // operand. [...]
Richard Smith0d729102012-08-13 20:08:14 +0000382 if (RecordD->isPolymorphic() && E->isGLValue()) {
Eli Friedmanef331b72012-01-20 01:26:23 +0000383 // The subexpression is potentially evaluated; switch the context
384 // and recheck the subexpression.
Benjamin Krameraccaf192012-11-14 15:08:31 +0000385 ExprResult Result = TransformToPotentiallyEvaluated(E);
Eli Friedmanef331b72012-01-20 01:26:23 +0000386 if (Result.isInvalid()) return ExprError();
387 E = Result.take();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000388
389 // We require a vtable to query the type at run time.
390 MarkVTableUsed(TypeidLoc, RecordD);
391 }
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000392 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000393
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000394 // C++ [expr.typeid]p4:
395 // [...] If the type of the type-id is a reference to a possibly
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000396 // cv-qualified type, the result of the typeid expression refers to a
397 // std::type_info object representing the cv-unqualified referenced
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000398 // type.
Douglas Gregord1c1d7b2010-06-02 06:16:02 +0000399 Qualifiers Quals;
400 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
401 if (!Context.hasSameType(T, UnqualT)) {
402 T = UnqualT;
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +0000403 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).take();
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000404 }
405 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000406
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000407 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
John McCall9ae2f072010-08-23 23:25:46 +0000408 E,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000409 SourceRange(TypeidLoc, RParenLoc)));
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000410}
411
412/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
John McCall60d7b3a2010-08-24 06:29:42 +0000413ExprResult
Sebastian Redlc42e1182008-11-11 11:37:55 +0000414Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
415 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000416 // Find the std::type_info type.
Sebastian Redlce0682f2011-03-31 19:29:24 +0000417 if (!getStdNamespace())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000418 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000419
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000420 if (!CXXTypeInfoDecl) {
421 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
422 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
423 LookupQualifiedName(R, getStdNamespace());
424 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
Nico Webered36b2a2012-06-19 23:58:27 +0000425 // Microsoft's typeinfo doesn't have type_info in std but in the global
426 // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
427 if (!CXXTypeInfoDecl && LangOpts.MicrosoftMode) {
428 LookupQualifiedName(R, Context.getTranslationUnitDecl());
429 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
430 }
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000431 if (!CXXTypeInfoDecl)
432 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
433 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000434
Nico Weber11d1a692012-05-20 01:27:21 +0000435 if (!getLangOpts().RTTI) {
436 return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
437 }
438
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000439 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000440
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000441 if (isType) {
442 // The operand is a type; handle it as such.
443 TypeSourceInfo *TInfo = 0;
John McCallb3d87482010-08-24 05:47:05 +0000444 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
445 &TInfo);
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000446 if (T.isNull())
447 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000448
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000449 if (!TInfo)
450 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +0000451
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000452 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
Douglas Gregorac7610d2009-06-22 20:57:11 +0000453 }
Mike Stump1eb44332009-09-09 15:08:12 +0000454
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000455 // The operand is an expression.
John McCall9ae2f072010-08-23 23:25:46 +0000456 return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +0000457}
458
Francois Pichet01b7c302010-09-08 12:20:18 +0000459/// \brief Build a Microsoft __uuidof expression with a type operand.
460ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
461 SourceLocation TypeidLoc,
462 TypeSourceInfo *Operand,
463 SourceLocation RParenLoc) {
Francois Pichet6915c522010-12-27 01:32:00 +0000464 if (!Operand->getType()->isDependentType()) {
Nico Weberc5f80462012-10-11 10:13:44 +0000465 if (!CXXUuidofExpr::GetUuidAttrOfType(Operand->getType()))
Francois Pichet6915c522010-12-27 01:32:00 +0000466 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
467 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000468
Francois Pichet01b7c302010-09-08 12:20:18 +0000469 // FIXME: add __uuidof semantic analysis for type operand.
470 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(),
471 Operand,
472 SourceRange(TypeidLoc, RParenLoc)));
473}
474
475/// \brief Build a Microsoft __uuidof expression with an expression operand.
476ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
477 SourceLocation TypeidLoc,
478 Expr *E,
479 SourceLocation RParenLoc) {
Francois Pichet6915c522010-12-27 01:32:00 +0000480 if (!E->getType()->isDependentType()) {
Nico Weberc5f80462012-10-11 10:13:44 +0000481 if (!CXXUuidofExpr::GetUuidAttrOfType(E->getType()) &&
Francois Pichet6915c522010-12-27 01:32:00 +0000482 !E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
483 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
484 }
485 // FIXME: add __uuidof semantic analysis for type operand.
Francois Pichet01b7c302010-09-08 12:20:18 +0000486 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(),
487 E,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000488 SourceRange(TypeidLoc, RParenLoc)));
Francois Pichet01b7c302010-09-08 12:20:18 +0000489}
490
491/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
492ExprResult
493Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
494 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000495 // If MSVCGuidDecl has not been cached, do the lookup.
Francois Pichet01b7c302010-09-08 12:20:18 +0000496 if (!MSVCGuidDecl) {
497 IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
498 LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
499 LookupQualifiedName(R, Context.getTranslationUnitDecl());
500 MSVCGuidDecl = R.getAsSingle<RecordDecl>();
501 if (!MSVCGuidDecl)
502 return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000503 }
504
Francois Pichet01b7c302010-09-08 12:20:18 +0000505 QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000506
Francois Pichet01b7c302010-09-08 12:20:18 +0000507 if (isType) {
508 // The operand is a type; handle it as such.
509 TypeSourceInfo *TInfo = 0;
510 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
511 &TInfo);
512 if (T.isNull())
513 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000514
Francois Pichet01b7c302010-09-08 12:20:18 +0000515 if (!TInfo)
516 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
517
518 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
519 }
520
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000521 // The operand is an expression.
Francois Pichet01b7c302010-09-08 12:20:18 +0000522 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
523}
524
Steve Naroff1b273c42007-09-16 14:56:35 +0000525/// ActOnCXXBoolLiteral - Parse {true,false} literals.
John McCall60d7b3a2010-08-24 06:29:42 +0000526ExprResult
Steve Naroff1b273c42007-09-16 14:56:35 +0000527Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
Douglas Gregor2f639b92008-10-24 15:36:09 +0000528 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
Reid Spencer5f016e22007-07-11 17:01:13 +0000529 "Unknown C++ Boolean value!");
Sebastian Redlf53597f2009-03-15 17:47:39 +0000530 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
531 Context.BoolTy, OpLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +0000532}
Chris Lattner50dd2892008-02-26 00:51:44 +0000533
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000534/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
John McCall60d7b3a2010-08-24 06:29:42 +0000535ExprResult
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000536Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
537 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
538}
539
Chris Lattner50dd2892008-02-26 00:51:44 +0000540/// ActOnCXXThrow - Parse throw expressions.
John McCall60d7b3a2010-08-24 06:29:42 +0000541ExprResult
Douglas Gregorbca01b42011-07-06 22:04:06 +0000542Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {
543 bool IsThrownVarInScope = false;
544 if (Ex) {
545 // C++0x [class.copymove]p31:
546 // When certain criteria are met, an implementation is allowed to omit the
547 // copy/move construction of a class object [...]
548 //
549 // - in a throw-expression, when the operand is the name of a
550 // non-volatile automatic object (other than a function or catch-
551 // clause parameter) whose scope does not extend beyond the end of the
552 // innermost enclosing try-block (if there is one), the copy/move
553 // operation from the operand to the exception object (15.1) can be
554 // omitted by constructing the automatic object directly into the
555 // exception object
556 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
557 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
558 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
559 for( ; S; S = S->getParent()) {
560 if (S->isDeclScope(Var)) {
561 IsThrownVarInScope = true;
562 break;
563 }
564
565 if (S->getFlags() &
566 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
567 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
568 Scope::TryScope))
569 break;
570 }
571 }
572 }
573 }
574
575 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
576}
577
578ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
579 bool IsThrownVarInScope) {
Anders Carlsson729b8532011-02-23 03:46:46 +0000580 // Don't report an error if 'throw' is used in system headers.
David Blaikie4e4d0842012-03-11 07:00:24 +0000581 if (!getLangOpts().CXXExceptions &&
Anders Carlsson729b8532011-02-23 03:46:46 +0000582 !getSourceManager().isInSystemHeader(OpLoc))
Anders Carlssonb1fba312011-02-19 21:53:09 +0000583 Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
Douglas Gregorbca01b42011-07-06 22:04:06 +0000584
John Wiegley429bb272011-04-08 18:41:53 +0000585 if (Ex && !Ex->isTypeDependent()) {
Douglas Gregorbca01b42011-07-06 22:04:06 +0000586 ExprResult ExRes = CheckCXXThrowOperand(OpLoc, Ex, IsThrownVarInScope);
John Wiegley429bb272011-04-08 18:41:53 +0000587 if (ExRes.isInvalid())
588 return ExprError();
589 Ex = ExRes.take();
590 }
Douglas Gregorbca01b42011-07-06 22:04:06 +0000591
592 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc,
593 IsThrownVarInScope));
Sebastian Redl972041f2009-04-27 20:27:31 +0000594}
595
596/// CheckCXXThrowOperand - Validate the operand of a throw.
Douglas Gregorbca01b42011-07-06 22:04:06 +0000597ExprResult Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *E,
598 bool IsThrownVarInScope) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000599 // C++ [except.throw]p3:
Douglas Gregor154fe982009-12-23 22:04:40 +0000600 // A throw-expression initializes a temporary object, called the exception
601 // object, the type of which is determined by removing any top-level
602 // cv-qualifiers from the static type of the operand of throw and adjusting
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000603 // the type from "array of T" or "function returning T" to "pointer to T"
Douglas Gregor154fe982009-12-23 22:04:40 +0000604 // or "pointer to function returning T", [...]
605 if (E->getType().hasQualifiers())
John Wiegley429bb272011-04-08 18:41:53 +0000606 E = ImpCastExprToType(E, E->getType().getUnqualifiedType(), CK_NoOp,
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +0000607 E->getValueKind()).take();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000608
John Wiegley429bb272011-04-08 18:41:53 +0000609 ExprResult Res = DefaultFunctionArrayConversion(E);
610 if (Res.isInvalid())
611 return ExprError();
612 E = Res.take();
Sebastian Redl972041f2009-04-27 20:27:31 +0000613
614 // If the type of the exception would be an incomplete type or a pointer
615 // to an incomplete type other than (cv) void the program is ill-formed.
616 QualType Ty = E->getType();
John McCallac418162010-04-22 01:10:34 +0000617 bool isPointer = false;
Ted Kremenek6217b802009-07-29 21:53:49 +0000618 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000619 Ty = Ptr->getPointeeType();
John McCallac418162010-04-22 01:10:34 +0000620 isPointer = true;
Sebastian Redl972041f2009-04-27 20:27:31 +0000621 }
622 if (!isPointer || !Ty->isVoidType()) {
623 if (RequireCompleteType(ThrowLoc, Ty,
Douglas Gregord10099e2012-05-04 16:32:21 +0000624 isPointer? diag::err_throw_incomplete_ptr
625 : diag::err_throw_incomplete,
626 E->getSourceRange()))
John Wiegley429bb272011-04-08 18:41:53 +0000627 return ExprError();
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000628
Douglas Gregorbf422f92010-04-15 18:05:39 +0000629 if (RequireNonAbstractType(ThrowLoc, E->getType(),
Douglas Gregor6a26e2e2012-05-04 17:09:59 +0000630 diag::err_throw_abstract_type, E))
John Wiegley429bb272011-04-08 18:41:53 +0000631 return ExprError();
Sebastian Redl972041f2009-04-27 20:27:31 +0000632 }
633
John McCallac418162010-04-22 01:10:34 +0000634 // Initialize the exception result. This implicitly weeds out
635 // abstract types or types with inaccessible copy constructors.
Douglas Gregorbca01b42011-07-06 22:04:06 +0000636
637 // C++0x [class.copymove]p31:
638 // When certain criteria are met, an implementation is allowed to omit the
639 // copy/move construction of a class object [...]
640 //
641 // - in a throw-expression, when the operand is the name of a
642 // non-volatile automatic object (other than a function or catch-clause
643 // parameter) whose scope does not extend beyond the end of the
644 // innermost enclosing try-block (if there is one), the copy/move
645 // operation from the operand to the exception object (15.1) can be
646 // omitted by constructing the automatic object directly into the
647 // exception object
648 const VarDecl *NRVOVariable = 0;
649 if (IsThrownVarInScope)
650 NRVOVariable = getCopyElisionCandidate(QualType(), E, false);
651
John McCallac418162010-04-22 01:10:34 +0000652 InitializedEntity Entity =
Douglas Gregor72dfa272011-01-21 22:46:35 +0000653 InitializedEntity::InitializeException(ThrowLoc, E->getType(),
Douglas Gregorbca01b42011-07-06 22:04:06 +0000654 /*NRVO=*/NRVOVariable != 0);
John Wiegley429bb272011-04-08 18:41:53 +0000655 Res = PerformMoveOrCopyInitialization(Entity, NRVOVariable,
Douglas Gregorbca01b42011-07-06 22:04:06 +0000656 QualType(), E,
657 IsThrownVarInScope);
John McCallac418162010-04-22 01:10:34 +0000658 if (Res.isInvalid())
John Wiegley429bb272011-04-08 18:41:53 +0000659 return ExprError();
660 E = Res.take();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000661
Eli Friedman5ed9b932010-06-03 20:39:03 +0000662 // If the exception has class type, we need additional handling.
663 const RecordType *RecordTy = Ty->getAs<RecordType>();
664 if (!RecordTy)
John Wiegley429bb272011-04-08 18:41:53 +0000665 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000666 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
667
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000668 // If we are throwing a polymorphic class type or pointer thereof,
669 // exception handling will make use of the vtable.
Eli Friedman5ed9b932010-06-03 20:39:03 +0000670 MarkVTableUsed(ThrowLoc, RD);
671
Eli Friedman98efb9f2010-10-12 20:32:36 +0000672 // If a pointer is thrown, the referenced object will not be destroyed.
673 if (isPointer)
John Wiegley429bb272011-04-08 18:41:53 +0000674 return Owned(E);
Eli Friedman98efb9f2010-10-12 20:32:36 +0000675
Richard Smith213d70b2012-02-18 04:13:32 +0000676 // If the class has a destructor, we must be able to call it.
677 if (RD->hasIrrelevantDestructor())
John Wiegley429bb272011-04-08 18:41:53 +0000678 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000679
Sebastian Redl28357452012-03-05 19:35:43 +0000680 CXXDestructorDecl *Destructor = LookupDestructor(RD);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000681 if (!Destructor)
John Wiegley429bb272011-04-08 18:41:53 +0000682 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000683
Eli Friedman5f2987c2012-02-02 03:46:19 +0000684 MarkFunctionReferenced(E->getExprLoc(), Destructor);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000685 CheckDestructorAccess(E->getExprLoc(), Destructor,
Douglas Gregored8abf12010-07-08 06:14:04 +0000686 PDiag(diag::err_access_dtor_exception) << Ty);
Richard Smith82f145d2013-05-04 06:44:46 +0000687 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
688 return ExprError();
John Wiegley429bb272011-04-08 18:41:53 +0000689 return Owned(E);
Chris Lattner50dd2892008-02-26 00:51:44 +0000690}
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000691
Eli Friedman72899c32012-01-07 04:59:52 +0000692QualType Sema::getCurrentThisType() {
693 DeclContext *DC = getFunctionLevelDeclContext();
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000694 QualType ThisTy = CXXThisTypeOverride;
Richard Smith7a614d82011-06-11 17:19:42 +0000695 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
696 if (method && method->isInstance())
697 ThisTy = method->getThisType(Context);
Richard Smith7a614d82011-06-11 17:19:42 +0000698 }
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000699
Richard Smith7a614d82011-06-11 17:19:42 +0000700 return ThisTy;
John McCall5808ce42011-02-03 08:15:49 +0000701}
702
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000703Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S,
704 Decl *ContextDecl,
705 unsigned CXXThisTypeQuals,
706 bool Enabled)
707 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
708{
709 if (!Enabled || !ContextDecl)
710 return;
711
712 CXXRecordDecl *Record = 0;
713 if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
714 Record = Template->getTemplatedDecl();
715 else
716 Record = cast<CXXRecordDecl>(ContextDecl);
717
718 S.CXXThisTypeOverride
719 = S.Context.getPointerType(
720 S.Context.getRecordType(Record).withCVRQualifiers(CXXThisTypeQuals));
721
722 this->Enabled = true;
723}
724
725
726Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
727 if (Enabled) {
728 S.CXXThisTypeOverride = OldCXXThisTypeOverride;
729 }
730}
731
Ben Langmuir3a2f9122013-04-29 13:32:41 +0000732static Expr *captureThis(ASTContext &Context, RecordDecl *RD,
733 QualType ThisTy, SourceLocation Loc) {
734 FieldDecl *Field
735 = FieldDecl::Create(Context, RD, Loc, Loc, 0, ThisTy,
736 Context.getTrivialTypeSourceInfo(ThisTy, Loc),
737 0, false, ICIS_NoInit);
738 Field->setImplicit(true);
739 Field->setAccess(AS_private);
740 RD->addDecl(Field);
741 return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/true);
742}
743
Douglas Gregora1f21142012-02-01 17:04:21 +0000744void Sema::CheckCXXThisCapture(SourceLocation Loc, bool Explicit) {
Eli Friedman72899c32012-01-07 04:59:52 +0000745 // We don't need to capture this in an unevaluated context.
John McCallaeeacf72013-05-03 00:10:13 +0000746 if (isUnevaluatedContext() && !Explicit)
Eli Friedman72899c32012-01-07 04:59:52 +0000747 return;
748
749 // Otherwise, check that we can capture 'this'.
750 unsigned NumClosures = 0;
751 for (unsigned idx = FunctionScopes.size() - 1; idx != 0; idx--) {
Eli Friedmanb69b42c2012-01-11 02:36:31 +0000752 if (CapturingScopeInfo *CSI =
753 dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
754 if (CSI->CXXThisCaptureIndex != 0) {
755 // 'this' is already being captured; there isn't anything more to do.
Eli Friedman72899c32012-01-07 04:59:52 +0000756 break;
757 }
Douglas Gregora1f21142012-02-01 17:04:21 +0000758
Eli Friedmanb69b42c2012-01-11 02:36:31 +0000759 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
Douglas Gregor3ac109c2012-02-10 17:46:20 +0000760 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
Douglas Gregora1f21142012-02-01 17:04:21 +0000761 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000762 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
Douglas Gregora1f21142012-02-01 17:04:21 +0000763 Explicit) {
764 // This closure can capture 'this'; continue looking upwards.
Eli Friedman72899c32012-01-07 04:59:52 +0000765 NumClosures++;
Douglas Gregora1f21142012-02-01 17:04:21 +0000766 Explicit = false;
Eli Friedman72899c32012-01-07 04:59:52 +0000767 continue;
768 }
Eli Friedmanb69b42c2012-01-11 02:36:31 +0000769 // This context can't implicitly capture 'this'; fail out.
Douglas Gregora1f21142012-02-01 17:04:21 +0000770 Diag(Loc, diag::err_this_capture) << Explicit;
Eli Friedman72899c32012-01-07 04:59:52 +0000771 return;
772 }
Eli Friedman72899c32012-01-07 04:59:52 +0000773 break;
774 }
775
776 // Mark that we're implicitly capturing 'this' in all the scopes we skipped.
777 // FIXME: We need to delay this marking in PotentiallyPotentiallyEvaluated
778 // contexts.
779 for (unsigned idx = FunctionScopes.size() - 1;
780 NumClosures; --idx, --NumClosures) {
Eli Friedmanb69b42c2012-01-11 02:36:31 +0000781 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
Eli Friedman668165a2012-02-11 02:51:16 +0000782 Expr *ThisExpr = 0;
Douglas Gregor999713e2012-02-18 09:37:24 +0000783 QualType ThisTy = getCurrentThisType();
Ben Langmuir3a2f9122013-04-29 13:32:41 +0000784 if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI))
Eli Friedman668165a2012-02-11 02:51:16 +0000785 // For lambda expressions, build a field and an initializing expression.
Ben Langmuir3a2f9122013-04-29 13:32:41 +0000786 ThisExpr = captureThis(Context, LSI->Lambda, ThisTy, Loc);
787 else if (CapturedRegionScopeInfo *RSI
788 = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
789 ThisExpr = captureThis(Context, RSI->TheRecordDecl, ThisTy, Loc);
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000790
Eli Friedmanb69b42c2012-01-11 02:36:31 +0000791 bool isNested = NumClosures > 1;
Douglas Gregor999713e2012-02-18 09:37:24 +0000792 CSI->addThisCapture(isNested, Loc, ThisTy, ThisExpr);
Eli Friedman72899c32012-01-07 04:59:52 +0000793 }
794}
795
Richard Smith7a614d82011-06-11 17:19:42 +0000796ExprResult Sema::ActOnCXXThis(SourceLocation Loc) {
John McCall5808ce42011-02-03 08:15:49 +0000797 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
798 /// is a non-lvalue expression whose value is the address of the object for
799 /// which the function is called.
800
Douglas Gregor341350e2011-10-18 16:47:30 +0000801 QualType ThisTy = getCurrentThisType();
Richard Smith7a614d82011-06-11 17:19:42 +0000802 if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
John McCall5808ce42011-02-03 08:15:49 +0000803
Eli Friedman72899c32012-01-07 04:59:52 +0000804 CheckCXXThisCapture(Loc);
Richard Smith7a614d82011-06-11 17:19:42 +0000805 return Owned(new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000806}
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000807
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000808bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) {
809 // If we're outside the body of a member function, then we'll have a specified
810 // type for 'this'.
811 if (CXXThisTypeOverride.isNull())
812 return false;
813
814 // Determine whether we're looking into a class that's currently being
815 // defined.
816 CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl();
817 return Class && Class->isBeingDefined();
818}
819
John McCall60d7b3a2010-08-24 06:29:42 +0000820ExprResult
Douglas Gregorab6677e2010-09-08 00:15:04 +0000821Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000822 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000823 MultiExprArg exprs,
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000824 SourceLocation RParenLoc) {
Douglas Gregorae4c77d2010-02-05 19:11:37 +0000825 if (!TypeRep)
826 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000827
John McCall9d125032010-01-15 18:39:57 +0000828 TypeSourceInfo *TInfo;
829 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
830 if (!TInfo)
831 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
Douglas Gregorab6677e2010-09-08 00:15:04 +0000832
833 return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
834}
835
836/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
837/// Can be interpreted either as function-style casting ("int(x)")
838/// or class type construction ("ClassType(x,y,z)")
839/// or creation of a value-initialized type ("int()").
840ExprResult
841Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
842 SourceLocation LParenLoc,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000843 MultiExprArg Exprs,
Douglas Gregorab6677e2010-09-08 00:15:04 +0000844 SourceLocation RParenLoc) {
845 QualType Ty = TInfo->getType();
Douglas Gregorab6677e2010-09-08 00:15:04 +0000846 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000847
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000848 if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
Douglas Gregorab6677e2010-09-08 00:15:04 +0000849 return Owned(CXXUnresolvedConstructExpr::Create(Context, TInfo,
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000850 LParenLoc,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000851 Exprs,
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000852 RParenLoc));
Douglas Gregorba498172009-03-13 21:01:28 +0000853 }
854
Sebastian Redl6dc00f62012-02-12 18:41:05 +0000855 bool ListInitialization = LParenLoc.isInvalid();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000856 assert((!ListInitialization || (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0])))
Sebastian Redl6dc00f62012-02-12 18:41:05 +0000857 && "List initialization must have initializer list as expression.");
858 SourceRange FullRange = SourceRange(TyBeginLoc,
859 ListInitialization ? Exprs[0]->getSourceRange().getEnd() : RParenLoc);
860
Douglas Gregor506ae412009-01-16 18:33:17 +0000861 // C++ [expr.type.conv]p1:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000862 // If the expression list is a single expression, the type conversion
863 // expression is equivalent (in definedness, and if defined in meaning) to the
864 // corresponding cast expression.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000865 if (Exprs.size() == 1 && !ListInitialization) {
John McCallb45ae252011-10-05 07:41:44 +0000866 Expr *Arg = Exprs[0];
John McCallb45ae252011-10-05 07:41:44 +0000867 return BuildCXXFunctionalCastExpr(TInfo, LParenLoc, Arg, RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000868 }
869
Eli Friedmanc60ccf52012-02-29 00:00:28 +0000870 QualType ElemTy = Ty;
871 if (Ty->isArrayType()) {
872 if (!ListInitialization)
873 return ExprError(Diag(TyBeginLoc,
874 diag::err_value_init_for_array_type) << FullRange);
875 ElemTy = Context.getBaseElementType(Ty);
876 }
877
878 if (!Ty->isVoidType() &&
879 RequireCompleteType(TyBeginLoc, ElemTy,
Douglas Gregord10099e2012-05-04 16:32:21 +0000880 diag::err_invalid_incomplete_type_use, FullRange))
Eli Friedmanc60ccf52012-02-29 00:00:28 +0000881 return ExprError();
882
883 if (RequireNonAbstractType(TyBeginLoc, Ty,
884 diag::err_allocation_of_abstract_type))
885 return ExprError();
886
Douglas Gregor19311e72010-09-08 21:40:08 +0000887 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000888 InitializationKind Kind =
889 Exprs.size() ? ListInitialization
890 ? InitializationKind::CreateDirectList(TyBeginLoc)
891 : InitializationKind::CreateDirect(TyBeginLoc, LParenLoc, RParenLoc)
892 : InitializationKind::CreateValue(TyBeginLoc, LParenLoc, RParenLoc);
893 InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
894 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
Sebastian Redlf53597f2009-03-15 17:47:39 +0000895
Sebastian Redl20ff0e22012-02-13 19:55:43 +0000896 if (!Result.isInvalid() && ListInitialization &&
897 isa<InitListExpr>(Result.get())) {
898 // If the list-initialization doesn't involve a constructor call, we'll get
899 // the initializer-list (with corrected type) back, but that's not what we
900 // want, since it will be treated as an initializer list in further
901 // processing. Explicitly insert a cast here.
902 InitListExpr *List = cast<InitListExpr>(Result.take());
903 Result = Owned(CXXFunctionalCastExpr::Create(Context, List->getType(),
904 Expr::getValueKindForType(TInfo->getType()),
905 TInfo, TyBeginLoc, CK_NoOp,
906 List, /*Path=*/0, RParenLoc));
907 }
908
Douglas Gregor19311e72010-09-08 21:40:08 +0000909 // FIXME: Improve AST representation?
Benjamin Kramer3fe198b2012-08-23 21:35:17 +0000910 return Result;
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000911}
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +0000912
John McCall6ec278d2011-01-27 09:37:56 +0000913/// doesUsualArrayDeleteWantSize - Answers whether the usual
914/// operator delete[] for the given type has a size_t parameter.
915static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
916 QualType allocType) {
917 const RecordType *record =
918 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
919 if (!record) return false;
920
921 // Try to find an operator delete[] in class scope.
922
923 DeclarationName deleteName =
924 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
925 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
926 S.LookupQualifiedName(ops, record->getDecl());
927
928 // We're just doing this for information.
929 ops.suppressDiagnostics();
930
931 // Very likely: there's no operator delete[].
932 if (ops.empty()) return false;
933
934 // If it's ambiguous, it should be illegal to call operator delete[]
935 // on this thing, so it doesn't matter if we allocate extra space or not.
936 if (ops.isAmbiguous()) return false;
937
938 LookupResult::Filter filter = ops.makeFilter();
939 while (filter.hasNext()) {
940 NamedDecl *del = filter.next()->getUnderlyingDecl();
941
942 // C++0x [basic.stc.dynamic.deallocation]p2:
943 // A template instance is never a usual deallocation function,
944 // regardless of its signature.
945 if (isa<FunctionTemplateDecl>(del)) {
946 filter.erase();
947 continue;
948 }
949
950 // C++0x [basic.stc.dynamic.deallocation]p2:
951 // If class T does not declare [an operator delete[] with one
952 // parameter] but does declare a member deallocation function
953 // named operator delete[] with exactly two parameters, the
954 // second of which has type std::size_t, then this function
955 // is a usual deallocation function.
956 if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) {
957 filter.erase();
958 continue;
959 }
960 }
961 filter.done();
962
963 if (!ops.isSingleResult()) return false;
964
965 const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl());
966 return (del->getNumParams() == 2);
967}
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +0000968
Sebastian Redl6dc00f62012-02-12 18:41:05 +0000969/// \brief Parsed a C++ 'new' expression (C++ 5.3.4).
James Dennettef2b5b32012-06-15 22:23:43 +0000970///
Sebastian Redl6dc00f62012-02-12 18:41:05 +0000971/// E.g.:
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000972/// @code new (memory) int[size][4] @endcode
973/// or
974/// @code ::new Foo(23, "hello") @endcode
Sebastian Redl6dc00f62012-02-12 18:41:05 +0000975///
976/// \param StartLoc The first location of the expression.
977/// \param UseGlobal True if 'new' was prefixed with '::'.
978/// \param PlacementLParen Opening paren of the placement arguments.
979/// \param PlacementArgs Placement new arguments.
980/// \param PlacementRParen Closing paren of the placement arguments.
981/// \param TypeIdParens If the type is in parens, the source range.
982/// \param D The type to be allocated, as well as array dimensions.
James Dennettef2b5b32012-06-15 22:23:43 +0000983/// \param Initializer The initializing expression or initializer-list, or null
984/// if there is none.
John McCall60d7b3a2010-08-24 06:29:42 +0000985ExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000986Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000987 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000988 SourceLocation PlacementRParen, SourceRange TypeIdParens,
Sebastian Redl2aed8b82012-02-16 12:22:20 +0000989 Declarator &D, Expr *Initializer) {
Richard Smitha2c36462013-04-26 16:15:35 +0000990 bool TypeContainsAuto = D.getDeclSpec().containsPlaceholderType();
Richard Smith34b41d92011-02-20 03:19:35 +0000991
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000992 Expr *ArraySize = 0;
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000993 // If the specified type is an array, unwrap it and save the expression.
994 if (D.getNumTypeObjects() > 0 &&
995 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
James Dennettef2b5b32012-06-15 22:23:43 +0000996 DeclaratorChunk &Chunk = D.getTypeObject(0);
Richard Smith34b41d92011-02-20 03:19:35 +0000997 if (TypeContainsAuto)
998 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
999 << D.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001000 if (Chunk.Arr.hasStatic)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001001 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
1002 << D.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001003 if (!Chunk.Arr.NumElts)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001004 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
1005 << D.getSourceRange());
Sebastian Redl8ce35b02009-10-25 21:45:37 +00001006
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001007 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
Sebastian Redl8ce35b02009-10-25 21:45:37 +00001008 D.DropFirstTypeObject();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001009 }
1010
Douglas Gregor043cad22009-09-11 00:18:58 +00001011 // Every dimension shall be of constant size.
Sebastian Redl8ce35b02009-10-25 21:45:37 +00001012 if (ArraySize) {
1013 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
Douglas Gregor043cad22009-09-11 00:18:58 +00001014 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
1015 break;
1016
1017 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
1018 if (Expr *NumElts = (Expr *)Array.NumElts) {
Richard Smith282e7e62012-02-04 09:53:13 +00001019 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
Douglas Gregorab41fe92012-05-04 22:38:52 +00001020 Array.NumElts
1021 = VerifyIntegerConstantExpression(NumElts, 0,
1022 diag::err_new_array_nonconst)
1023 .take();
Richard Smith282e7e62012-02-04 09:53:13 +00001024 if (!Array.NumElts)
1025 return ExprError();
Douglas Gregor043cad22009-09-11 00:18:58 +00001026 }
1027 }
1028 }
1029 }
Sebastian Redl8ce35b02009-10-25 21:45:37 +00001030
Argyrios Kyrtzidis0b8c98f2011-06-28 03:01:23 +00001031 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/0);
John McCallbf1a0282010-06-04 23:28:52 +00001032 QualType AllocType = TInfo->getType();
Chris Lattnereaaebc72009-04-25 08:06:05 +00001033 if (D.isInvalidType())
Sebastian Redlf53597f2009-03-15 17:47:39 +00001034 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001035
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001036 SourceRange DirectInitRange;
1037 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1038 DirectInitRange = List->getSourceRange();
1039
David Blaikie53056412012-11-07 00:12:38 +00001040 return BuildCXXNew(SourceRange(StartLoc, D.getLocEnd()), UseGlobal,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001041 PlacementLParen,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001042 PlacementArgs,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001043 PlacementRParen,
Douglas Gregor4bd40312010-07-13 15:54:32 +00001044 TypeIdParens,
Mike Stump1eb44332009-09-09 15:08:12 +00001045 AllocType,
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001046 TInfo,
John McCall9ae2f072010-08-23 23:25:46 +00001047 ArraySize,
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001048 DirectInitRange,
1049 Initializer,
Richard Smith34b41d92011-02-20 03:19:35 +00001050 TypeContainsAuto);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001051}
1052
Sebastian Redlbd45d252012-02-16 12:59:47 +00001053static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
1054 Expr *Init) {
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001055 if (!Init)
1056 return true;
Sebastian Redl1f278052012-02-17 08:42:32 +00001057 if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
1058 return PLE->getNumExprs() == 0;
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001059 if (isa<ImplicitValueInitExpr>(Init))
1060 return true;
1061 else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
1062 return !CCE->isListInitialization() &&
1063 CCE->getConstructor()->isDefaultConstructor();
Sebastian Redlbd45d252012-02-16 12:59:47 +00001064 else if (Style == CXXNewExpr::ListInit) {
1065 assert(isa<InitListExpr>(Init) &&
1066 "Shouldn't create list CXXConstructExprs for arrays.");
1067 return true;
1068 }
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001069 return false;
1070}
1071
John McCall60d7b3a2010-08-24 06:29:42 +00001072ExprResult
David Blaikie53056412012-11-07 00:12:38 +00001073Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001074 SourceLocation PlacementLParen,
1075 MultiExprArg PlacementArgs,
1076 SourceLocation PlacementRParen,
Douglas Gregor4bd40312010-07-13 15:54:32 +00001077 SourceRange TypeIdParens,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001078 QualType AllocType,
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001079 TypeSourceInfo *AllocTypeInfo,
John McCall9ae2f072010-08-23 23:25:46 +00001080 Expr *ArraySize,
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001081 SourceRange DirectInitRange,
1082 Expr *Initializer,
Richard Smith34b41d92011-02-20 03:19:35 +00001083 bool TypeMayContainAuto) {
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001084 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
David Blaikie53056412012-11-07 00:12:38 +00001085 SourceLocation StartLoc = Range.getBegin();
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001086
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001087 CXXNewExpr::InitializationStyle initStyle;
1088 if (DirectInitRange.isValid()) {
1089 assert(Initializer && "Have parens but no initializer.");
1090 initStyle = CXXNewExpr::CallInit;
1091 } else if (Initializer && isa<InitListExpr>(Initializer))
1092 initStyle = CXXNewExpr::ListInit;
1093 else {
1094 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1095 isa<CXXConstructExpr>(Initializer)) &&
1096 "Initializer expression that cannot have been implicitly created.");
1097 initStyle = CXXNewExpr::NoInit;
1098 }
1099
1100 Expr **Inits = &Initializer;
1101 unsigned NumInits = Initializer ? 1 : 0;
Richard Smith73ed67c2012-11-26 08:32:48 +00001102 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1103 assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
1104 Inits = List->getExprs();
1105 NumInits = List->getNumExprs();
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001106 }
1107
Richard Smith73ed67c2012-11-26 08:32:48 +00001108 // Determine whether we've already built the initializer.
1109 bool HaveCompleteInit = false;
1110 if (Initializer && isa<CXXConstructExpr>(Initializer) &&
1111 !isa<CXXTemporaryObjectExpr>(Initializer))
1112 HaveCompleteInit = true;
1113 else if (Initializer && isa<ImplicitValueInitExpr>(Initializer))
1114 HaveCompleteInit = true;
1115
Richard Smith8ad6c862012-07-08 04:13:07 +00001116 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
Richard Smithdc7a4f52013-04-30 13:56:41 +00001117 if (TypeMayContainAuto && AllocType->isUndeducedType()) {
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001118 if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
Richard Smith34b41d92011-02-20 03:19:35 +00001119 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1120 << AllocType << TypeRange);
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001121 if (initStyle == CXXNewExpr::ListInit)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001122 return ExprError(Diag(Inits[0]->getLocStart(),
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001123 diag::err_auto_new_requires_parens)
1124 << AllocType << TypeRange);
1125 if (NumInits > 1) {
1126 Expr *FirstBad = Inits[1];
Daniel Dunbar96a00142012-03-09 18:35:03 +00001127 return ExprError(Diag(FirstBad->getLocStart(),
Richard Smith34b41d92011-02-20 03:19:35 +00001128 diag::err_auto_new_ctor_multiple_expressions)
1129 << AllocType << TypeRange);
1130 }
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001131 Expr *Deduce = Inits[0];
Richard Smith9b131752013-04-30 21:23:01 +00001132 QualType DeducedType;
Richard Smith8ad6c862012-07-08 04:13:07 +00001133 if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
Richard Smith34b41d92011-02-20 03:19:35 +00001134 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001135 << AllocType << Deduce->getType()
1136 << TypeRange << Deduce->getSourceRange());
Richard Smith9b131752013-04-30 21:23:01 +00001137 if (DeducedType.isNull())
Richard Smitha085da82011-03-17 16:11:59 +00001138 return ExprError();
Richard Smith9b131752013-04-30 21:23:01 +00001139 AllocType = DeducedType;
Richard Smith34b41d92011-02-20 03:19:35 +00001140 }
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001141
Douglas Gregor3caf04e2010-05-16 16:01:03 +00001142 // Per C++0x [expr.new]p5, the type being constructed may be a
1143 // typedef of an array type.
John McCall9ae2f072010-08-23 23:25:46 +00001144 if (!ArraySize) {
Douglas Gregor3caf04e2010-05-16 16:01:03 +00001145 if (const ConstantArrayType *Array
1146 = Context.getAsConstantArrayType(AllocType)) {
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00001147 ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
1148 Context.getSizeType(),
1149 TypeRange.getEnd());
Douglas Gregor3caf04e2010-05-16 16:01:03 +00001150 AllocType = Array->getElementType();
1151 }
1152 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001153
Douglas Gregora0750762010-10-06 16:00:31 +00001154 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
1155 return ExprError();
1156
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001157 if (initStyle == CXXNewExpr::ListInit && isStdInitializerList(AllocType, 0)) {
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001158 Diag(AllocTypeInfo->getTypeLoc().getBeginLoc(),
1159 diag::warn_dangling_std_initializer_list)
Sebastian Redl772291a2012-02-19 16:31:05 +00001160 << /*at end of FE*/0 << Inits[0]->getSourceRange();
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001161 }
1162
John McCallf85e1932011-06-15 23:02:42 +00001163 // In ARC, infer 'retaining' for the allocated
David Blaikie4e4d0842012-03-11 07:00:24 +00001164 if (getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001165 AllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1166 AllocType->isObjCLifetimeType()) {
1167 AllocType = Context.getLifetimeQualifiedType(AllocType,
1168 AllocType->getObjCARCImplicitLifetime());
1169 }
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001170
John McCallf85e1932011-06-15 23:02:42 +00001171 QualType ResultType = Context.getPointerType(AllocType);
1172
John McCall76da55d2013-04-16 07:28:30 +00001173 if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) {
1174 ExprResult result = CheckPlaceholderExpr(ArraySize);
1175 if (result.isInvalid()) return ExprError();
1176 ArraySize = result.take();
1177 }
Richard Smithf39aec12012-02-04 07:07:42 +00001178 // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have
1179 // integral or enumeration type with a non-negative value."
1180 // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped
1181 // enumeration type, or a class type for which a single non-explicit
1182 // conversion function to integral or unscoped enumeration type exists.
Sebastian Redl28507842009-02-26 14:39:58 +00001183 if (ArraySize && !ArraySize->isTypeDependent()) {
Douglas Gregorab41fe92012-05-04 22:38:52 +00001184 class SizeConvertDiagnoser : public ICEConvertDiagnoser {
1185 Expr *ArraySize;
1186
1187 public:
1188 SizeConvertDiagnoser(Expr *ArraySize)
1189 : ICEConvertDiagnoser(false, false), ArraySize(ArraySize) { }
1190
1191 virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1192 QualType T) {
1193 return S.Diag(Loc, diag::err_array_size_not_integral)
Richard Smith80ad52f2013-01-02 11:42:31 +00001194 << S.getLangOpts().CPlusPlus11 << T;
Douglas Gregorab41fe92012-05-04 22:38:52 +00001195 }
1196
1197 virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
1198 QualType T) {
1199 return S.Diag(Loc, diag::err_array_size_incomplete_type)
1200 << T << ArraySize->getSourceRange();
1201 }
1202
1203 virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S,
1204 SourceLocation Loc,
1205 QualType T,
1206 QualType ConvTy) {
1207 return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1208 }
1209
1210 virtual DiagnosticBuilder noteExplicitConv(Sema &S,
1211 CXXConversionDecl *Conv,
1212 QualType ConvTy) {
1213 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1214 << ConvTy->isEnumeralType() << ConvTy;
1215 }
1216
1217 virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
1218 QualType T) {
1219 return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1220 }
1221
1222 virtual DiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
1223 QualType ConvTy) {
1224 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1225 << ConvTy->isEnumeralType() << ConvTy;
1226 }
1227
1228 virtual DiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1229 QualType T,
1230 QualType ConvTy) {
1231 return S.Diag(Loc,
Richard Smith80ad52f2013-01-02 11:42:31 +00001232 S.getLangOpts().CPlusPlus11
Douglas Gregorab41fe92012-05-04 22:38:52 +00001233 ? diag::warn_cxx98_compat_array_size_conversion
1234 : diag::ext_array_size_conversion)
1235 << T << ConvTy->isEnumeralType() << ConvTy;
1236 }
1237 } SizeDiagnoser(ArraySize);
1238
1239 ExprResult ConvertedSize
1240 = ConvertToIntegralOrEnumerationType(StartLoc, ArraySize, SizeDiagnoser,
1241 /*AllowScopedEnumerations*/ false);
Douglas Gregor6bc574d2010-06-30 00:20:43 +00001242 if (ConvertedSize.isInvalid())
1243 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001244
John McCall9ae2f072010-08-23 23:25:46 +00001245 ArraySize = ConvertedSize.take();
John McCall806054d2012-01-11 00:14:46 +00001246 QualType SizeType = ArraySize->getType();
Douglas Gregor1274ccd2010-10-08 23:50:27 +00001247 if (!SizeType->isIntegralOrUnscopedEnumerationType())
Douglas Gregor6bc574d2010-06-30 00:20:43 +00001248 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001249
Richard Smith0b458fd2012-02-04 05:35:53 +00001250 // C++98 [expr.new]p7:
1251 // The expression in a direct-new-declarator shall have integral type
1252 // with a non-negative value.
1253 //
1254 // Let's see if this is a constant < 0. If so, we reject it out of
1255 // hand. Otherwise, if it's not a constant, we must have an unparenthesized
1256 // array type.
1257 //
1258 // Note: such a construct has well-defined semantics in C++11: it throws
1259 // std::bad_array_new_length.
Sebastian Redl28507842009-02-26 14:39:58 +00001260 if (!ArraySize->isValueDependent()) {
1261 llvm::APSInt Value;
Richard Smith282e7e62012-02-04 09:53:13 +00001262 // We've already performed any required implicit conversion to integer or
1263 // unscoped enumeration type.
Richard Smith0b458fd2012-02-04 05:35:53 +00001264 if (ArraySize->isIntegerConstantExpr(Value, Context)) {
Sebastian Redl28507842009-02-26 14:39:58 +00001265 if (Value < llvm::APSInt(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001266 llvm::APInt::getNullValue(Value.getBitWidth()),
Richard Smith0b458fd2012-02-04 05:35:53 +00001267 Value.isUnsigned())) {
Richard Smith80ad52f2013-01-02 11:42:31 +00001268 if (getLangOpts().CPlusPlus11)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001269 Diag(ArraySize->getLocStart(),
Richard Smith0b458fd2012-02-04 05:35:53 +00001270 diag::warn_typecheck_negative_array_new_size)
Douglas Gregor2767ce22010-08-18 00:39:00 +00001271 << ArraySize->getSourceRange();
Richard Smith0b458fd2012-02-04 05:35:53 +00001272 else
Daniel Dunbar96a00142012-03-09 18:35:03 +00001273 return ExprError(Diag(ArraySize->getLocStart(),
Richard Smith0b458fd2012-02-04 05:35:53 +00001274 diag::err_typecheck_negative_array_size)
1275 << ArraySize->getSourceRange());
1276 } else if (!AllocType->isDependentType()) {
1277 unsigned ActiveSizeBits =
1278 ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
1279 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
Richard Smith80ad52f2013-01-02 11:42:31 +00001280 if (getLangOpts().CPlusPlus11)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001281 Diag(ArraySize->getLocStart(),
Richard Smith0b458fd2012-02-04 05:35:53 +00001282 diag::warn_array_new_too_large)
1283 << Value.toString(10)
1284 << ArraySize->getSourceRange();
1285 else
Daniel Dunbar96a00142012-03-09 18:35:03 +00001286 return ExprError(Diag(ArraySize->getLocStart(),
Richard Smith0b458fd2012-02-04 05:35:53 +00001287 diag::err_array_too_large)
1288 << Value.toString(10)
1289 << ArraySize->getSourceRange());
Douglas Gregor2767ce22010-08-18 00:39:00 +00001290 }
1291 }
Douglas Gregor4bd40312010-07-13 15:54:32 +00001292 } else if (TypeIdParens.isValid()) {
1293 // Can't have dynamic array size when the type-id is in parentheses.
1294 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
1295 << ArraySize->getSourceRange()
1296 << FixItHint::CreateRemoval(TypeIdParens.getBegin())
1297 << FixItHint::CreateRemoval(TypeIdParens.getEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001298
Douglas Gregor4bd40312010-07-13 15:54:32 +00001299 TypeIdParens = SourceRange();
Sebastian Redl28507842009-02-26 14:39:58 +00001300 }
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001301 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001302
John McCall7d166272011-05-15 07:14:44 +00001303 // Note that we do *not* convert the argument in any way. It can
1304 // be signed, larger than size_t, whatever.
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001305 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001306
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001307 FunctionDecl *OperatorNew = 0;
1308 FunctionDecl *OperatorDelete = 0;
Benjamin Kramer5354e772012-08-23 23:38:35 +00001309 Expr **PlaceArgs = PlacementArgs.data();
Sebastian Redlf53597f2009-03-15 17:47:39 +00001310 unsigned NumPlaceArgs = PlacementArgs.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001311
Sebastian Redl28507842009-02-26 14:39:58 +00001312 if (!AllocType->isDependentType() &&
Ahmed Charles13a140c2012-02-25 11:00:22 +00001313 !Expr::hasAnyTypeDependentArguments(
1314 llvm::makeArrayRef(PlaceArgs, NumPlaceArgs)) &&
Sebastian Redl28507842009-02-26 14:39:58 +00001315 FindAllocationFunctions(StartLoc,
Sebastian Redl00e68e22009-02-09 18:24:27 +00001316 SourceRange(PlacementLParen, PlacementRParen),
1317 UseGlobal, AllocType, ArraySize, PlaceArgs,
1318 NumPlaceArgs, OperatorNew, OperatorDelete))
Sebastian Redlf53597f2009-03-15 17:47:39 +00001319 return ExprError();
John McCall6ec278d2011-01-27 09:37:56 +00001320
1321 // If this is an array allocation, compute whether the usual array
1322 // deallocation function for the type has a size_t parameter.
1323 bool UsualArrayDeleteWantsSize = false;
1324 if (ArraySize && !AllocType->isDependentType())
1325 UsualArrayDeleteWantsSize
1326 = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
1327
Chris Lattner5f9e2722011-07-23 10:55:15 +00001328 SmallVector<Expr *, 8> AllPlaceArgs;
Fariborz Jahanian498429f2009-11-19 18:39:40 +00001329 if (OperatorNew) {
1330 // Add default arguments, if any.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001331 const FunctionProtoType *Proto =
Fariborz Jahanian498429f2009-11-19 18:39:40 +00001332 OperatorNew->getType()->getAs<FunctionProtoType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001333 VariadicCallType CallType =
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00001334 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001335
Anders Carlsson28e94832010-05-03 02:07:56 +00001336 if (GatherArgumentsForCall(PlacementLParen, OperatorNew,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001337 Proto, 1, PlaceArgs, NumPlaceArgs,
Anders Carlsson28e94832010-05-03 02:07:56 +00001338 AllPlaceArgs, CallType))
Fariborz Jahanian048f52a2009-11-24 18:29:37 +00001339 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001340
Fariborz Jahanian498429f2009-11-19 18:39:40 +00001341 NumPlaceArgs = AllPlaceArgs.size();
1342 if (NumPlaceArgs > 0)
1343 PlaceArgs = &AllPlaceArgs[0];
Eli Friedmane61eb042012-02-18 04:48:30 +00001344
1345 DiagnoseSentinelCalls(OperatorNew, PlacementLParen,
1346 PlaceArgs, NumPlaceArgs);
1347
1348 // FIXME: Missing call to CheckFunctionCall or equivalent
Fariborz Jahanian498429f2009-11-19 18:39:40 +00001349 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001350
Nick Lewyckyfca84b22012-01-24 21:15:41 +00001351 // Warn if the type is over-aligned and is being allocated by global operator
1352 // new.
Nick Lewycky507a8a32012-02-04 03:30:14 +00001353 if (NumPlaceArgs == 0 && OperatorNew &&
Nick Lewyckyfca84b22012-01-24 21:15:41 +00001354 (OperatorNew->isImplicit() ||
1355 getSourceManager().isInSystemHeader(OperatorNew->getLocStart()))) {
1356 if (unsigned Align = Context.getPreferredTypeAlign(AllocType.getTypePtr())){
1357 unsigned SuitableAlign = Context.getTargetInfo().getSuitableAlign();
1358 if (Align > SuitableAlign)
1359 Diag(StartLoc, diag::warn_overaligned_type)
1360 << AllocType
1361 << unsigned(Align / Context.getCharWidth())
1362 << unsigned(SuitableAlign / Context.getCharWidth());
1363 }
1364 }
1365
Sebastian Redlbd45d252012-02-16 12:59:47 +00001366 QualType InitType = AllocType;
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001367 // Array 'new' can't have any initializers except empty parentheses.
Sebastian Redlbd45d252012-02-16 12:59:47 +00001368 // Initializer lists are also allowed, in C++11. Rely on the parser for the
1369 // dialect distinction.
1370 if (ResultType->isArrayType() || ArraySize) {
1371 if (!isLegalArrayNewInitializer(initStyle, Initializer)) {
1372 SourceRange InitRange(Inits[0]->getLocStart(),
1373 Inits[NumInits - 1]->getLocEnd());
1374 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
1375 return ExprError();
1376 }
1377 if (InitListExpr *ILE = dyn_cast_or_null<InitListExpr>(Initializer)) {
1378 // We do the initialization typechecking against the array type
1379 // corresponding to the number of initializers + 1 (to also check
1380 // default-initialization).
1381 unsigned NumElements = ILE->getNumInits() + 1;
1382 InitType = Context.getConstantArrayType(AllocType,
1383 llvm::APInt(Context.getTypeSize(Context.getSizeType()), NumElements),
1384 ArrayType::Normal, 0);
1385 }
Anders Carlsson48c95012010-05-03 15:45:23 +00001386 }
1387
Richard Smith73ed67c2012-11-26 08:32:48 +00001388 // If we can perform the initialization, and we've not already done so,
1389 // do it now.
Douglas Gregor99a2e602009-12-16 01:38:02 +00001390 if (!AllocType->isDependentType() &&
Ahmed Charles13a140c2012-02-25 11:00:22 +00001391 !Expr::hasAnyTypeDependentArguments(
Richard Smith73ed67c2012-11-26 08:32:48 +00001392 llvm::makeArrayRef(Inits, NumInits)) &&
1393 !HaveCompleteInit) {
Sebastian Redl6dc00f62012-02-12 18:41:05 +00001394 // C++11 [expr.new]p15:
Douglas Gregor99a2e602009-12-16 01:38:02 +00001395 // A new-expression that creates an object of type T initializes that
1396 // object as follows:
1397 InitializationKind Kind
1398 // - If the new-initializer is omitted, the object is default-
1399 // initialized (8.5); if no initialization is performed,
1400 // the object has indeterminate value
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001401 = initStyle == CXXNewExpr::NoInit
1402 ? InitializationKind::CreateDefault(TypeRange.getBegin())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001403 // - Otherwise, the new-initializer is interpreted according to the
Douglas Gregor99a2e602009-12-16 01:38:02 +00001404 // initialization rules of 8.5 for direct-initialization.
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001405 : initStyle == CXXNewExpr::ListInit
1406 ? InitializationKind::CreateDirectList(TypeRange.getBegin())
1407 : InitializationKind::CreateDirect(TypeRange.getBegin(),
1408 DirectInitRange.getBegin(),
1409 DirectInitRange.getEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001410
Douglas Gregor99a2e602009-12-16 01:38:02 +00001411 InitializedEntity Entity
Sebastian Redlbd45d252012-02-16 12:59:47 +00001412 = InitializedEntity::InitializeNew(StartLoc, InitType);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00001413 InitializationSequence InitSeq(*this, Entity, Kind, MultiExprArg(Inits, NumInits));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001414 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001415 MultiExprArg(Inits, NumInits));
Douglas Gregor99a2e602009-12-16 01:38:02 +00001416 if (FullInit.isInvalid())
1417 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001418
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001419 // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
1420 // we don't want the initialized object to be destructed.
1421 if (CXXBindTemporaryExpr *Binder =
1422 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))
1423 FullInit = Owned(Binder->getSubExpr());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001424
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001425 Initializer = FullInit.take();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001426 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001427
Douglas Gregor6d908702010-02-26 05:06:18 +00001428 // Mark the new and delete operators as referenced.
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00001429 if (OperatorNew) {
Richard Smith82f145d2013-05-04 06:44:46 +00001430 if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
1431 return ExprError();
Eli Friedman5f2987c2012-02-02 03:46:19 +00001432 MarkFunctionReferenced(StartLoc, OperatorNew);
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00001433 }
1434 if (OperatorDelete) {
Richard Smith82f145d2013-05-04 06:44:46 +00001435 if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
1436 return ExprError();
Eli Friedman5f2987c2012-02-02 03:46:19 +00001437 MarkFunctionReferenced(StartLoc, OperatorDelete);
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00001438 }
Douglas Gregor6d908702010-02-26 05:06:18 +00001439
John McCall84ff0fc2011-07-13 20:12:57 +00001440 // C++0x [expr.new]p17:
1441 // If the new expression creates an array of objects of class type,
1442 // access and ambiguity control are done for the destructor.
David Blaikie426d6ca2012-03-10 23:40:02 +00001443 QualType BaseAllocType = Context.getBaseElementType(AllocType);
1444 if (ArraySize && !BaseAllocType->isDependentType()) {
1445 if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
1446 if (CXXDestructorDecl *dtor = LookupDestructor(
1447 cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
1448 MarkFunctionReferenced(StartLoc, dtor);
1449 CheckDestructorAccess(StartLoc, dtor,
1450 PDiag(diag::err_access_dtor)
1451 << BaseAllocType);
Richard Smith82f145d2013-05-04 06:44:46 +00001452 if (DiagnoseUseOfDecl(dtor, StartLoc))
1453 return ExprError();
David Blaikie426d6ca2012-03-10 23:40:02 +00001454 }
John McCall84ff0fc2011-07-13 20:12:57 +00001455 }
1456 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001457
Ted Kremenekad7fe862010-02-11 22:51:03 +00001458 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00001459 OperatorDelete,
John McCall6ec278d2011-01-27 09:37:56 +00001460 UsualArrayDeleteWantsSize,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001461 llvm::makeArrayRef(PlaceArgs, NumPlaceArgs),
1462 TypeIdParens,
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001463 ArraySize, initStyle, Initializer,
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001464 ResultType, AllocTypeInfo,
David Blaikie53056412012-11-07 00:12:38 +00001465 Range, DirectInitRange));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001466}
1467
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001468/// \brief Checks that a type is suitable as the allocated type
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001469/// in a new-expression.
Douglas Gregor3433cf72009-05-21 00:00:09 +00001470bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +00001471 SourceRange R) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001472 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
1473 // abstract class type or array thereof.
Douglas Gregore7450f52009-03-24 19:52:54 +00001474 if (AllocType->isFunctionType())
Douglas Gregor3433cf72009-05-21 00:00:09 +00001475 return Diag(Loc, diag::err_bad_new_type)
1476 << AllocType << 0 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +00001477 else if (AllocType->isReferenceType())
Douglas Gregor3433cf72009-05-21 00:00:09 +00001478 return Diag(Loc, diag::err_bad_new_type)
1479 << AllocType << 1 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +00001480 else if (!AllocType->isDependentType() &&
Douglas Gregord10099e2012-05-04 16:32:21 +00001481 RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001482 return true;
Douglas Gregor3433cf72009-05-21 00:00:09 +00001483 else if (RequireNonAbstractType(Loc, AllocType,
Douglas Gregore7450f52009-03-24 19:52:54 +00001484 diag::err_allocation_of_abstract_type))
1485 return true;
Douglas Gregora0750762010-10-06 16:00:31 +00001486 else if (AllocType->isVariablyModifiedType())
1487 return Diag(Loc, diag::err_variably_modified_new_type)
1488 << AllocType;
Douglas Gregor5666d362011-04-15 19:46:20 +00001489 else if (unsigned AddressSpace = AllocType.getAddressSpace())
1490 return Diag(Loc, diag::err_address_space_qualified_new)
1491 << AllocType.getUnqualifiedType() << AddressSpace;
David Blaikie4e4d0842012-03-11 07:00:24 +00001492 else if (getLangOpts().ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +00001493 if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {
1494 QualType BaseAllocType = Context.getBaseElementType(AT);
1495 if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1496 BaseAllocType->isObjCLifetimeType())
Argyrios Kyrtzidisb8b03132011-06-24 00:08:59 +00001497 return Diag(Loc, diag::err_arc_new_array_without_ownership)
John McCallf85e1932011-06-15 23:02:42 +00001498 << BaseAllocType;
1499 }
1500 }
Douglas Gregor5666d362011-04-15 19:46:20 +00001501
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001502 return false;
1503}
1504
Douglas Gregor6d908702010-02-26 05:06:18 +00001505/// \brief Determine whether the given function is a non-placement
1506/// deallocation function.
1507static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) {
1508 if (FD->isInvalidDecl())
1509 return false;
1510
1511 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1512 return Method->isUsualDeallocationFunction();
1513
1514 return ((FD->getOverloadedOperator() == OO_Delete ||
1515 FD->getOverloadedOperator() == OO_Array_Delete) &&
1516 FD->getNumParams() == 1);
1517}
1518
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001519/// FindAllocationFunctions - Finds the overloads of operator new and delete
1520/// that are appropriate for the allocation.
Sebastian Redl00e68e22009-02-09 18:24:27 +00001521bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1522 bool UseGlobal, QualType AllocType,
1523 bool IsArray, Expr **PlaceArgs,
1524 unsigned NumPlaceArgs,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001525 FunctionDecl *&OperatorNew,
Mike Stump1eb44332009-09-09 15:08:12 +00001526 FunctionDecl *&OperatorDelete) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001527 // --- Choosing an allocation function ---
1528 // C++ 5.3.4p8 - 14 & 18
1529 // 1) If UseGlobal is true, only look in the global scope. Else, also look
1530 // in the scope of the allocated class.
1531 // 2) If an array size is given, look for operator new[], else look for
1532 // operator new.
1533 // 3) The first argument is always size_t. Append the arguments from the
1534 // placement form.
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001535
Chris Lattner5f9e2722011-07-23 10:55:15 +00001536 SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001537 // We don't care about the actual value of this argument.
1538 // FIXME: Should the Sema create the expression and embed it in the syntax
1539 // tree? Or should the consumer just recalculate the value?
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00001540 IntegerLiteral Size(Context, llvm::APInt::getNullValue(
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001541 Context.getTargetInfo().getPointerWidth(0)),
Anders Carlssond67c4c32009-08-16 20:29:29 +00001542 Context.getSizeType(),
1543 SourceLocation());
1544 AllocArgs[0] = &Size;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001545 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
1546
Douglas Gregor6d908702010-02-26 05:06:18 +00001547 // C++ [expr.new]p8:
1548 // If the allocated type is a non-array type, the allocation
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001549 // function's name is operator new and the deallocation function's
Douglas Gregor6d908702010-02-26 05:06:18 +00001550 // name is operator delete. If the allocated type is an array
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001551 // type, the allocation function's name is operator new[] and the
1552 // deallocation function's name is operator delete[].
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001553 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
1554 IsArray ? OO_Array_New : OO_New);
Douglas Gregor6d908702010-02-26 05:06:18 +00001555 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1556 IsArray ? OO_Array_Delete : OO_Delete);
1557
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001558 QualType AllocElemType = Context.getBaseElementType(AllocType);
1559
1560 if (AllocElemType->isRecordType() && !UseGlobal) {
Mike Stump1eb44332009-09-09 15:08:12 +00001561 CXXRecordDecl *Record
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001562 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Sebastian Redl00e68e22009-02-09 18:24:27 +00001563 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +00001564 AllocArgs.size(), Record, /*AllowMissing=*/true,
1565 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001566 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001567 }
1568 if (!OperatorNew) {
1569 // Didn't find a member overload. Look for a global one.
1570 DeclareGlobalNewDelete();
Sebastian Redl7f662392008-12-04 22:20:51 +00001571 DeclContext *TUDecl = Context.getTranslationUnitDecl();
Sebastian Redl00e68e22009-02-09 18:24:27 +00001572 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +00001573 AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
1574 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001575 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001576 }
1577
John McCall9c82afc2010-04-20 02:18:25 +00001578 // We don't need an operator delete if we're running under
1579 // -fno-exceptions.
David Blaikie4e4d0842012-03-11 07:00:24 +00001580 if (!getLangOpts().Exceptions) {
John McCall9c82afc2010-04-20 02:18:25 +00001581 OperatorDelete = 0;
1582 return false;
1583 }
1584
Anders Carlssond9583892009-05-31 20:26:12 +00001585 // FindAllocationOverload can change the passed in arguments, so we need to
1586 // copy them back.
1587 if (NumPlaceArgs > 0)
1588 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00001589
Douglas Gregor6d908702010-02-26 05:06:18 +00001590 // C++ [expr.new]p19:
1591 //
1592 // If the new-expression begins with a unary :: operator, the
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001593 // deallocation function's name is looked up in the global
Douglas Gregor6d908702010-02-26 05:06:18 +00001594 // scope. Otherwise, if the allocated type is a class type T or an
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001595 // array thereof, the deallocation function's name is looked up in
Douglas Gregor6d908702010-02-26 05:06:18 +00001596 // the scope of T. If this lookup fails to find the name, or if
1597 // the allocated type is not a class type or array thereof, the
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001598 // deallocation function's name is looked up in the global scope.
Douglas Gregor6d908702010-02-26 05:06:18 +00001599 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001600 if (AllocElemType->isRecordType() && !UseGlobal) {
Douglas Gregor6d908702010-02-26 05:06:18 +00001601 CXXRecordDecl *RD
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001602 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Douglas Gregor6d908702010-02-26 05:06:18 +00001603 LookupQualifiedName(FoundDelete, RD);
1604 }
John McCall90c8c572010-03-18 08:19:33 +00001605 if (FoundDelete.isAmbiguous())
1606 return true; // FIXME: clean up expressions?
Douglas Gregor6d908702010-02-26 05:06:18 +00001607
1608 if (FoundDelete.empty()) {
1609 DeclareGlobalNewDelete();
1610 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
1611 }
1612
1613 FoundDelete.suppressDiagnostics();
John McCall9aa472c2010-03-19 07:35:19 +00001614
Chris Lattner5f9e2722011-07-23 10:55:15 +00001615 SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
John McCall9aa472c2010-03-19 07:35:19 +00001616
John McCalledeb6c92010-09-14 21:34:24 +00001617 // Whether we're looking for a placement operator delete is dictated
1618 // by whether we selected a placement operator new, not by whether
1619 // we had explicit placement arguments. This matters for things like
1620 // struct A { void *operator new(size_t, int = 0); ... };
1621 // A *a = new A()
1622 bool isPlacementNew = (NumPlaceArgs > 0 || OperatorNew->param_size() != 1);
1623
1624 if (isPlacementNew) {
Douglas Gregor6d908702010-02-26 05:06:18 +00001625 // C++ [expr.new]p20:
1626 // A declaration of a placement deallocation function matches the
1627 // declaration of a placement allocation function if it has the
1628 // same number of parameters and, after parameter transformations
1629 // (8.3.5), all parameter types except the first are
1630 // identical. [...]
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001631 //
Douglas Gregor6d908702010-02-26 05:06:18 +00001632 // To perform this comparison, we compute the function type that
1633 // the deallocation function should have, and use that type both
1634 // for template argument deduction and for comparison purposes.
John McCalle23cf432010-12-14 08:05:40 +00001635 //
1636 // FIXME: this comparison should ignore CC and the like.
Douglas Gregor6d908702010-02-26 05:06:18 +00001637 QualType ExpectedFunctionType;
1638 {
1639 const FunctionProtoType *Proto
1640 = OperatorNew->getType()->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00001641
Chris Lattner5f9e2722011-07-23 10:55:15 +00001642 SmallVector<QualType, 4> ArgTypes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001643 ArgTypes.push_back(Context.VoidPtrTy);
Douglas Gregor6d908702010-02-26 05:06:18 +00001644 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I)
1645 ArgTypes.push_back(Proto->getArgType(I));
1646
John McCalle23cf432010-12-14 08:05:40 +00001647 FunctionProtoType::ExtProtoInfo EPI;
1648 EPI.Variadic = Proto->isVariadic();
1649
Douglas Gregor6d908702010-02-26 05:06:18 +00001650 ExpectedFunctionType
Jordan Rosebea522f2013-03-08 21:51:21 +00001651 = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
Douglas Gregor6d908702010-02-26 05:06:18 +00001652 }
1653
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001654 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001655 DEnd = FoundDelete.end();
1656 D != DEnd; ++D) {
1657 FunctionDecl *Fn = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001658 if (FunctionTemplateDecl *FnTmpl
Douglas Gregor6d908702010-02-26 05:06:18 +00001659 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
1660 // Perform template argument deduction to try to match the
1661 // expected function type.
Craig Topper93e45992012-09-19 02:26:47 +00001662 TemplateDeductionInfo Info(StartLoc);
Douglas Gregor6d908702010-02-26 05:06:18 +00001663 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info))
1664 continue;
1665 } else
1666 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
1667
1668 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
John McCall9aa472c2010-03-19 07:35:19 +00001669 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +00001670 }
1671 } else {
1672 // C++ [expr.new]p20:
1673 // [...] Any non-placement deallocation function matches a
1674 // non-placement allocation function. [...]
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001675 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001676 DEnd = FoundDelete.end();
1677 D != DEnd; ++D) {
1678 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
1679 if (isNonPlacementDeallocationFunction(Fn))
John McCall9aa472c2010-03-19 07:35:19 +00001680 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +00001681 }
1682 }
1683
1684 // C++ [expr.new]p20:
1685 // [...] If the lookup finds a single matching deallocation
1686 // function, that function will be called; otherwise, no
1687 // deallocation function will be called.
1688 if (Matches.size() == 1) {
John McCall9aa472c2010-03-19 07:35:19 +00001689 OperatorDelete = Matches[0].second;
Douglas Gregor6d908702010-02-26 05:06:18 +00001690
1691 // C++0x [expr.new]p20:
1692 // If the lookup finds the two-parameter form of a usual
1693 // deallocation function (3.7.4.2) and that function, considered
1694 // as a placement deallocation function, would have been
1695 // selected as a match for the allocation function, the program
1696 // is ill-formed.
Richard Smith80ad52f2013-01-02 11:42:31 +00001697 if (NumPlaceArgs && getLangOpts().CPlusPlus11 &&
Douglas Gregor6d908702010-02-26 05:06:18 +00001698 isNonPlacementDeallocationFunction(OperatorDelete)) {
1699 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001700 << SourceRange(PlaceArgs[0]->getLocStart(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001701 PlaceArgs[NumPlaceArgs - 1]->getLocEnd());
1702 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1703 << DeleteName;
John McCall90c8c572010-03-18 08:19:33 +00001704 } else {
1705 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
John McCall9aa472c2010-03-19 07:35:19 +00001706 Matches[0].first);
Douglas Gregor6d908702010-02-26 05:06:18 +00001707 }
1708 }
1709
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001710 return false;
1711}
1712
Sebastian Redl7f662392008-12-04 22:20:51 +00001713/// FindAllocationOverload - Find an fitting overload for the allocation
1714/// function in the specified scope.
Sebastian Redl00e68e22009-02-09 18:24:27 +00001715bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1716 DeclarationName Name, Expr** Args,
1717 unsigned NumArgs, DeclContext *Ctx,
Sean Hunt2be7e902011-05-12 22:46:29 +00001718 bool AllowMissing, FunctionDecl *&Operator,
1719 bool Diagnose) {
John McCalla24dc2e2009-11-17 02:14:36 +00001720 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1721 LookupQualifiedName(R, Ctx);
John McCallf36e02d2009-10-09 21:13:30 +00001722 if (R.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001723 if (AllowMissing || !Diagnose)
Sebastian Redl7f662392008-12-04 22:20:51 +00001724 return false;
Sebastian Redl7f662392008-12-04 22:20:51 +00001725 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
Chris Lattner4330d652009-02-17 07:29:20 +00001726 << Name << Range;
Sebastian Redl7f662392008-12-04 22:20:51 +00001727 }
1728
John McCall90c8c572010-03-18 08:19:33 +00001729 if (R.isAmbiguous())
1730 return true;
1731
1732 R.suppressDiagnostics();
John McCallf36e02d2009-10-09 21:13:30 +00001733
John McCall5769d612010-02-08 23:07:23 +00001734 OverloadCandidateSet Candidates(StartLoc);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001735 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
Douglas Gregor5d64e5b2009-09-30 00:03:47 +00001736 Alloc != AllocEnd; ++Alloc) {
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001737 // Even member operator new/delete are implicitly treated as
1738 // static, so don't use AddMemberCandidate.
John McCall9aa472c2010-03-19 07:35:19 +00001739 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001740
John McCall9aa472c2010-03-19 07:35:19 +00001741 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1742 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
Ahmed Charles13a140c2012-02-25 11:00:22 +00001743 /*ExplicitTemplateArgs=*/0,
1744 llvm::makeArrayRef(Args, NumArgs),
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001745 Candidates,
1746 /*SuppressUserConversions=*/false);
Douglas Gregor90916562009-09-29 18:16:17 +00001747 continue;
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001748 }
1749
John McCall9aa472c2010-03-19 07:35:19 +00001750 FunctionDecl *Fn = cast<FunctionDecl>(D);
Ahmed Charles13a140c2012-02-25 11:00:22 +00001751 AddOverloadCandidate(Fn, Alloc.getPair(),
1752 llvm::makeArrayRef(Args, NumArgs), Candidates,
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001753 /*SuppressUserConversions=*/false);
Sebastian Redl7f662392008-12-04 22:20:51 +00001754 }
1755
1756 // Do the resolution.
1757 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00001758 switch (Candidates.BestViableFunction(*this, StartLoc, Best)) {
Sebastian Redl7f662392008-12-04 22:20:51 +00001759 case OR_Success: {
1760 // Got one!
1761 FunctionDecl *FnDecl = Best->Function;
Eli Friedman5f2987c2012-02-02 03:46:19 +00001762 MarkFunctionReferenced(StartLoc, FnDecl);
Sebastian Redl7f662392008-12-04 22:20:51 +00001763 // The first argument is size_t, and the first parameter must be size_t,
1764 // too. This is checked on declaration and can be assumed. (It can't be
1765 // asserted on, though, since invalid decls are left in there.)
John McCall90c8c572010-03-18 08:19:33 +00001766 // Watch out for variadic allocator function.
Fariborz Jahanian048f52a2009-11-24 18:29:37 +00001767 unsigned NumArgsInFnDecl = FnDecl->getNumParams();
1768 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001769 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
1770 FnDecl->getParamDecl(i));
1771
1772 if (!Diagnose && !CanPerformCopyInitialization(Entity, Owned(Args[i])))
1773 return true;
1774
John McCall60d7b3a2010-08-24 06:29:42 +00001775 ExprResult Result
Sean Hunt2be7e902011-05-12 22:46:29 +00001776 = PerformCopyInitialization(Entity, SourceLocation(), Owned(Args[i]));
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001777 if (Result.isInvalid())
Sebastian Redl7f662392008-12-04 22:20:51 +00001778 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001779
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001780 Args[i] = Result.takeAs<Expr>();
Sebastian Redl7f662392008-12-04 22:20:51 +00001781 }
Richard Smith9a561d52012-02-26 09:11:52 +00001782
Sebastian Redl7f662392008-12-04 22:20:51 +00001783 Operator = FnDecl;
Richard Smith9a561d52012-02-26 09:11:52 +00001784
1785 if (CheckAllocationAccess(StartLoc, Range, R.getNamingClass(),
1786 Best->FoundDecl, Diagnose) == AR_inaccessible)
1787 return true;
1788
Sebastian Redl7f662392008-12-04 22:20:51 +00001789 return false;
1790 }
1791
1792 case OR_No_Viable_Function:
Chandler Carruth361d3802011-06-08 10:26:03 +00001793 if (Diagnose) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001794 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
1795 << Name << Range;
Ahmed Charles13a140c2012-02-25 11:00:22 +00001796 Candidates.NoteCandidates(*this, OCD_AllCandidates,
1797 llvm::makeArrayRef(Args, NumArgs));
Chandler Carruth361d3802011-06-08 10:26:03 +00001798 }
Sebastian Redl7f662392008-12-04 22:20:51 +00001799 return true;
1800
1801 case OR_Ambiguous:
Chandler Carruth361d3802011-06-08 10:26:03 +00001802 if (Diagnose) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001803 Diag(StartLoc, diag::err_ovl_ambiguous_call)
1804 << Name << Range;
Ahmed Charles13a140c2012-02-25 11:00:22 +00001805 Candidates.NoteCandidates(*this, OCD_ViableCandidates,
1806 llvm::makeArrayRef(Args, NumArgs));
Chandler Carruth361d3802011-06-08 10:26:03 +00001807 }
Sebastian Redl7f662392008-12-04 22:20:51 +00001808 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001809
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001810 case OR_Deleted: {
Chandler Carruth361d3802011-06-08 10:26:03 +00001811 if (Diagnose) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001812 Diag(StartLoc, diag::err_ovl_deleted_call)
1813 << Best->Function->isDeleted()
1814 << Name
1815 << getDeletedOrUnavailableSuffix(Best->Function)
1816 << Range;
Ahmed Charles13a140c2012-02-25 11:00:22 +00001817 Candidates.NoteCandidates(*this, OCD_AllCandidates,
1818 llvm::makeArrayRef(Args, NumArgs));
Chandler Carruth361d3802011-06-08 10:26:03 +00001819 }
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001820 return true;
Sebastian Redl7f662392008-12-04 22:20:51 +00001821 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001822 }
David Blaikieb219cfc2011-09-23 05:06:16 +00001823 llvm_unreachable("Unreachable, bad result from BestViableFunction");
Sebastian Redl7f662392008-12-04 22:20:51 +00001824}
1825
1826
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001827/// DeclareGlobalNewDelete - Declare the global forms of operator new and
1828/// delete. These are:
1829/// @code
Sebastian Redl8999fe12011-03-14 18:08:30 +00001830/// // C++03:
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001831/// void* operator new(std::size_t) throw(std::bad_alloc);
1832/// void* operator new[](std::size_t) throw(std::bad_alloc);
1833/// void operator delete(void *) throw();
1834/// void operator delete[](void *) throw();
Sebastian Redl8999fe12011-03-14 18:08:30 +00001835/// // C++0x:
1836/// void* operator new(std::size_t);
1837/// void* operator new[](std::size_t);
1838/// void operator delete(void *);
1839/// void operator delete[](void *);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001840/// @endcode
Sebastian Redl8999fe12011-03-14 18:08:30 +00001841/// C++0x operator delete is implicitly noexcept.
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001842/// Note that the placement and nothrow forms of new are *not* implicitly
1843/// declared. Their use requires including \<new\>.
Mike Stump1eb44332009-09-09 15:08:12 +00001844void Sema::DeclareGlobalNewDelete() {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001845 if (GlobalNewDeleteDeclared)
1846 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001847
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001848 // C++ [basic.std.dynamic]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001849 // [...] The following allocation and deallocation functions (18.4) are
1850 // implicitly declared in global scope in each translation unit of a
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001851 // program
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001852 //
Sebastian Redl8999fe12011-03-14 18:08:30 +00001853 // C++03:
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001854 // void* operator new(std::size_t) throw(std::bad_alloc);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001855 // void* operator new[](std::size_t) throw(std::bad_alloc);
1856 // void operator delete(void*) throw();
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001857 // void operator delete[](void*) throw();
Sebastian Redl8999fe12011-03-14 18:08:30 +00001858 // C++0x:
1859 // void* operator new(std::size_t);
1860 // void* operator new[](std::size_t);
1861 // void operator delete(void*);
1862 // void operator delete[](void*);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001863 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001864 // These implicit declarations introduce only the function names operator
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001865 // new, operator new[], operator delete, operator delete[].
1866 //
1867 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
1868 // "std" or "bad_alloc" as necessary to form the exception specification.
1869 // However, we do not make these implicit declarations visible to name
1870 // lookup.
Sebastian Redl8999fe12011-03-14 18:08:30 +00001871 // Note that the C++0x versions of operator delete are deallocation functions,
1872 // and thus are implicitly noexcept.
Richard Smith80ad52f2013-01-02 11:42:31 +00001873 if (!StdBadAlloc && !getLangOpts().CPlusPlus11) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001874 // The "std::bad_alloc" class has not yet been declared, so build it
1875 // implicitly.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001876 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
1877 getOrCreateStdNamespace(),
Abramo Bagnaraba877ad2011-03-09 14:09:51 +00001878 SourceLocation(), SourceLocation(),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001879 &PP.getIdentifierTable().get("bad_alloc"),
Abramo Bagnaraba877ad2011-03-09 14:09:51 +00001880 0);
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00001881 getStdBadAlloc()->setImplicit(true);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001882 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001883
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001884 GlobalNewDeleteDeclared = true;
1885
1886 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
1887 QualType SizeT = Context.getSizeType();
David Blaikie4e4d0842012-03-11 07:00:24 +00001888 bool AssumeSaneOperatorNew = getLangOpts().AssumeSaneOperatorNew;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001889
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001890 DeclareGlobalAllocationFunction(
1891 Context.DeclarationNames.getCXXOperatorName(OO_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001892 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001893 DeclareGlobalAllocationFunction(
1894 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001895 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001896 DeclareGlobalAllocationFunction(
1897 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
1898 Context.VoidTy, VoidPtr);
1899 DeclareGlobalAllocationFunction(
1900 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
1901 Context.VoidTy, VoidPtr);
1902}
1903
1904/// DeclareGlobalAllocationFunction - Declares a single implicit global
1905/// allocation function if it doesn't already exist.
1906void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
Nuno Lopesfc284482009-12-16 16:59:22 +00001907 QualType Return, QualType Argument,
1908 bool AddMallocAttr) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001909 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
1910
1911 // Check if this function is already declared.
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001912 {
David Blaikie3bc93e32012-12-19 00:45:41 +00001913 DeclContext::lookup_result R = GlobalCtx->lookup(Name);
1914 for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end();
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001915 Alloc != AllocEnd; ++Alloc) {
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001916 // Only look at non-template functions, as it is the predefined,
1917 // non-templated allocation function we are trying to declare here.
1918 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
1919 QualType InitialParamType =
Douglas Gregor6e790ab2009-12-22 23:42:49 +00001920 Context.getCanonicalType(
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001921 Func->getParamDecl(0)->getType().getUnqualifiedType());
1922 // FIXME: Do we need to check for default arguments here?
Douglas Gregor7b868622010-08-18 15:06:25 +00001923 if (Func->getNumParams() == 1 && InitialParamType == Argument) {
1924 if(AddMallocAttr && !Func->hasAttr<MallocAttr>())
Sean Huntcf807c42010-08-18 23:23:40 +00001925 Func->addAttr(::new (Context) MallocAttr(SourceLocation(), Context));
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001926 return;
Douglas Gregor7b868622010-08-18 15:06:25 +00001927 }
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001928 }
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001929 }
1930 }
1931
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001932 QualType BadAllocType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001933 bool HasBadAllocExceptionSpec
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001934 = (Name.getCXXOverloadedOperator() == OO_New ||
1935 Name.getCXXOverloadedOperator() == OO_Array_New);
Richard Smith80ad52f2013-01-02 11:42:31 +00001936 if (HasBadAllocExceptionSpec && !getLangOpts().CPlusPlus11) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001937 assert(StdBadAlloc && "Must have std::bad_alloc declared");
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00001938 BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001939 }
John McCalle23cf432010-12-14 08:05:40 +00001940
1941 FunctionProtoType::ExtProtoInfo EPI;
John McCalle23cf432010-12-14 08:05:40 +00001942 if (HasBadAllocExceptionSpec) {
Richard Smith80ad52f2013-01-02 11:42:31 +00001943 if (!getLangOpts().CPlusPlus11) {
Sebastian Redl8999fe12011-03-14 18:08:30 +00001944 EPI.ExceptionSpecType = EST_Dynamic;
1945 EPI.NumExceptions = 1;
1946 EPI.Exceptions = &BadAllocType;
1947 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00001948 } else {
Richard Smith80ad52f2013-01-02 11:42:31 +00001949 EPI.ExceptionSpecType = getLangOpts().CPlusPlus11 ?
Sebastian Redl8999fe12011-03-14 18:08:30 +00001950 EST_BasicNoexcept : EST_DynamicNone;
John McCalle23cf432010-12-14 08:05:40 +00001951 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001952
Jordan Rosebea522f2013-03-08 21:51:21 +00001953 QualType FnType = Context.getFunctionType(Return, Argument, EPI);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001954 FunctionDecl *Alloc =
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001955 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(),
1956 SourceLocation(), Name,
Rafael Espindolad2615cc2013-04-03 19:27:57 +00001957 FnType, /*TInfo=*/0, SC_None, false, true);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001958 Alloc->setImplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001959
Nuno Lopesfc284482009-12-16 16:59:22 +00001960 if (AddMallocAttr)
Sean Huntcf807c42010-08-18 23:23:40 +00001961 Alloc->addAttr(::new (Context) MallocAttr(SourceLocation(), Context));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001962
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001963 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001964 SourceLocation(), 0,
1965 Argument, /*TInfo=*/0,
Rafael Espindolad2615cc2013-04-03 19:27:57 +00001966 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00001967 Alloc->setParams(Param);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001968
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001969 // FIXME: Also add this declaration to the IdentifierResolver, but
1970 // make sure it is at the end of the chain to coincide with the
1971 // global scope.
John McCall5f1e0942010-08-24 08:50:51 +00001972 Context.getTranslationUnitDecl()->addDecl(Alloc);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001973}
1974
Anders Carlsson78f74552009-11-15 18:45:20 +00001975bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
1976 DeclarationName Name,
Sean Hunt2be7e902011-05-12 22:46:29 +00001977 FunctionDecl* &Operator, bool Diagnose) {
John McCalla24dc2e2009-11-17 02:14:36 +00001978 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
Anders Carlsson78f74552009-11-15 18:45:20 +00001979 // Try to find operator delete/operator delete[] in class scope.
John McCalla24dc2e2009-11-17 02:14:36 +00001980 LookupQualifiedName(Found, RD);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001981
John McCalla24dc2e2009-11-17 02:14:36 +00001982 if (Found.isAmbiguous())
Anders Carlsson78f74552009-11-15 18:45:20 +00001983 return true;
Anders Carlsson78f74552009-11-15 18:45:20 +00001984
Chandler Carruth23893242010-06-28 00:30:51 +00001985 Found.suppressDiagnostics();
1986
Chris Lattner5f9e2722011-07-23 10:55:15 +00001987 SmallVector<DeclAccessPair,4> Matches;
Anders Carlsson78f74552009-11-15 18:45:20 +00001988 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1989 F != FEnd; ++F) {
Chandler Carruth09556fd2010-08-08 07:04:00 +00001990 NamedDecl *ND = (*F)->getUnderlyingDecl();
1991
1992 // Ignore template operator delete members from the check for a usual
1993 // deallocation function.
1994 if (isa<FunctionTemplateDecl>(ND))
1995 continue;
1996
1997 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction())
John McCall046a7462010-08-04 00:31:26 +00001998 Matches.push_back(F.getPair());
1999 }
2000
2001 // There's exactly one suitable operator; pick it.
2002 if (Matches.size() == 1) {
2003 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
Sean Hunt2be7e902011-05-12 22:46:29 +00002004
2005 if (Operator->isDeleted()) {
2006 if (Diagnose) {
2007 Diag(StartLoc, diag::err_deleted_function_use);
Richard Smith6c4c36c2012-03-30 20:53:28 +00002008 NoteDeletedFunction(Operator);
Sean Hunt2be7e902011-05-12 22:46:29 +00002009 }
2010 return true;
2011 }
2012
Richard Smith9a561d52012-02-26 09:11:52 +00002013 if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
2014 Matches[0], Diagnose) == AR_inaccessible)
2015 return true;
2016
John McCall046a7462010-08-04 00:31:26 +00002017 return false;
2018
2019 // We found multiple suitable operators; complain about the ambiguity.
2020 } else if (!Matches.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00002021 if (Diagnose) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00002022 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2023 << Name << RD;
John McCall046a7462010-08-04 00:31:26 +00002024
Chris Lattner5f9e2722011-07-23 10:55:15 +00002025 for (SmallVectorImpl<DeclAccessPair>::iterator
Sean Huntcb45a0f2011-05-12 22:46:25 +00002026 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F)
2027 Diag((*F)->getUnderlyingDecl()->getLocation(),
2028 diag::note_member_declared_here) << Name;
2029 }
John McCall046a7462010-08-04 00:31:26 +00002030 return true;
Anders Carlsson78f74552009-11-15 18:45:20 +00002031 }
2032
2033 // We did find operator delete/operator delete[] declarations, but
2034 // none of them were suitable.
2035 if (!Found.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00002036 if (Diagnose) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00002037 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2038 << Name << RD;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002039
Sean Huntcb45a0f2011-05-12 22:46:25 +00002040 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
2041 F != FEnd; ++F)
2042 Diag((*F)->getUnderlyingDecl()->getLocation(),
2043 diag::note_member_declared_here) << Name;
2044 }
Anders Carlsson78f74552009-11-15 18:45:20 +00002045 return true;
2046 }
2047
2048 // Look for a global declaration.
2049 DeclareGlobalNewDelete();
2050 DeclContext *TUDecl = Context.getTranslationUnitDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002051
Anders Carlsson78f74552009-11-15 18:45:20 +00002052 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation());
2053 Expr* DeallocArgs[1];
2054 DeallocArgs[0] = &Null;
2055 if (FindAllocationOverload(StartLoc, SourceRange(), Name,
Sean Hunt2be7e902011-05-12 22:46:29 +00002056 DeallocArgs, 1, TUDecl, !Diagnose,
2057 Operator, Diagnose))
Anders Carlsson78f74552009-11-15 18:45:20 +00002058 return true;
2059
2060 assert(Operator && "Did not find a deallocation function!");
2061 return false;
2062}
2063
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002064/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
2065/// @code ::delete ptr; @endcode
2066/// or
2067/// @code delete [] ptr; @endcode
John McCall60d7b3a2010-08-24 06:29:42 +00002068ExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002069Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
John Wiegley429bb272011-04-08 18:41:53 +00002070 bool ArrayForm, Expr *ExE) {
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002071 // C++ [expr.delete]p1:
2072 // The operand shall have a pointer type, or a class type having a single
2073 // conversion function to a pointer type. The result has type void.
2074 //
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002075 // DR599 amends "pointer type" to "pointer to object type" in both cases.
2076
John Wiegley429bb272011-04-08 18:41:53 +00002077 ExprResult Ex = Owned(ExE);
Anders Carlssond67c4c32009-08-16 20:29:29 +00002078 FunctionDecl *OperatorDelete = 0;
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00002079 bool ArrayFormAsWritten = ArrayForm;
John McCall6ec278d2011-01-27 09:37:56 +00002080 bool UsualArrayDeleteWantsSize = false;
Mike Stump1eb44332009-09-09 15:08:12 +00002081
John Wiegley429bb272011-04-08 18:41:53 +00002082 if (!Ex.get()->isTypeDependent()) {
John McCall5aba3eb2012-03-09 04:08:29 +00002083 // Perform lvalue-to-rvalue cast, if needed.
2084 Ex = DefaultLvalueConversion(Ex.take());
Eli Friedman206491d2012-12-13 00:37:17 +00002085 if (Ex.isInvalid())
2086 return ExprError();
John McCall5aba3eb2012-03-09 04:08:29 +00002087
John Wiegley429bb272011-04-08 18:41:53 +00002088 QualType Type = Ex.get()->getType();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002089
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002090 if (const RecordType *Record = Type->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002091 if (RequireCompleteType(StartLoc, Type,
Douglas Gregord10099e2012-05-04 16:32:21 +00002092 diag::err_delete_incomplete_class_type))
Douglas Gregor254a9422010-07-29 14:44:35 +00002093 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002094
Chris Lattner5f9e2722011-07-23 10:55:15 +00002095 SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions;
John McCall32daa422010-03-31 01:36:47 +00002096
Fariborz Jahanian53462782009-09-11 21:44:33 +00002097 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00002098 std::pair<CXXRecordDecl::conversion_iterator,
2099 CXXRecordDecl::conversion_iterator>
2100 Conversions = RD->getVisibleConversionFunctions();
2101 for (CXXRecordDecl::conversion_iterator
2102 I = Conversions.first, E = Conversions.second; I != E; ++I) {
John McCall32daa422010-03-31 01:36:47 +00002103 NamedDecl *D = I.getDecl();
2104 if (isa<UsingShadowDecl>(D))
2105 D = cast<UsingShadowDecl>(D)->getTargetDecl();
2106
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002107 // Skip over templated conversion functions; they aren't considered.
John McCall32daa422010-03-31 01:36:47 +00002108 if (isa<FunctionTemplateDecl>(D))
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002109 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002110
John McCall32daa422010-03-31 01:36:47 +00002111 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002112
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002113 QualType ConvType = Conv->getConversionType().getNonReferenceType();
2114 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
Eli Friedman13578692010-08-05 02:49:48 +00002115 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00002116 ObjectPtrConversions.push_back(Conv);
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002117 }
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00002118 if (ObjectPtrConversions.size() == 1) {
2119 // We have a single conversion to a pointer-to-object type. Perform
2120 // that conversion.
John McCall32daa422010-03-31 01:36:47 +00002121 // TODO: don't redo the conversion calculation.
John Wiegley429bb272011-04-08 18:41:53 +00002122 ExprResult Res =
2123 PerformImplicitConversion(Ex.get(),
John McCall32daa422010-03-31 01:36:47 +00002124 ObjectPtrConversions.front()->getConversionType(),
John Wiegley429bb272011-04-08 18:41:53 +00002125 AA_Converting);
2126 if (Res.isUsable()) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002127 Ex = Res;
John Wiegley429bb272011-04-08 18:41:53 +00002128 Type = Ex.get()->getType();
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00002129 }
2130 }
2131 else if (ObjectPtrConversions.size() > 1) {
2132 Diag(StartLoc, diag::err_ambiguous_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00002133 << Type << Ex.get()->getSourceRange();
John McCall32daa422010-03-31 01:36:47 +00002134 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++)
2135 NoteOverloadCandidate(ObjectPtrConversions[i]);
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00002136 return ExprError();
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00002137 }
Sebastian Redl28507842009-02-26 14:39:58 +00002138 }
2139
Sebastian Redlf53597f2009-03-15 17:47:39 +00002140 if (!Type->isPointerType())
2141 return ExprError(Diag(StartLoc, diag::err_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00002142 << Type << Ex.get()->getSourceRange());
Sebastian Redl28507842009-02-26 14:39:58 +00002143
Ted Kremenek6217b802009-07-29 21:53:49 +00002144 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
Eli Friedmane52c9142011-07-26 22:25:31 +00002145 QualType PointeeElem = Context.getBaseElementType(Pointee);
2146
2147 if (unsigned AddressSpace = Pointee.getAddressSpace())
2148 return Diag(Ex.get()->getLocStart(),
2149 diag::err_address_space_qualified_delete)
2150 << Pointee.getUnqualifiedType() << AddressSpace;
2151
2152 CXXRecordDecl *PointeeRD = 0;
Douglas Gregor94a61572010-05-24 17:01:56 +00002153 if (Pointee->isVoidType() && !isSFINAEContext()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002154 // The C++ standard bans deleting a pointer to a non-object type, which
Douglas Gregor94a61572010-05-24 17:01:56 +00002155 // effectively bans deletion of "void*". However, most compilers support
2156 // this, so we treat it as a warning unless we're in a SFINAE context.
2157 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
John Wiegley429bb272011-04-08 18:41:53 +00002158 << Type << Ex.get()->getSourceRange();
Eli Friedmane52c9142011-07-26 22:25:31 +00002159 } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
Sebastian Redlf53597f2009-03-15 17:47:39 +00002160 return ExprError(Diag(StartLoc, diag::err_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00002161 << Type << Ex.get()->getSourceRange());
Eli Friedmane52c9142011-07-26 22:25:31 +00002162 } else if (!Pointee->isDependentType()) {
2163 if (!RequireCompleteType(StartLoc, Pointee,
Douglas Gregord10099e2012-05-04 16:32:21 +00002164 diag::warn_delete_incomplete, Ex.get())) {
Eli Friedmane52c9142011-07-26 22:25:31 +00002165 if (const RecordType *RT = PointeeElem->getAs<RecordType>())
2166 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
2167 }
2168 }
2169
Douglas Gregor1070c9f2009-09-29 21:38:53 +00002170 // C++ [expr.delete]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002171 // [Note: a pointer to a const type can be the operand of a
2172 // delete-expression; it is not necessary to cast away the constness
2173 // (5.2.11) of the pointer expression before it is used as the operand
Douglas Gregor1070c9f2009-09-29 21:38:53 +00002174 // of the delete-expression. ]
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00002175
2176 if (Pointee->isArrayType() && !ArrayForm) {
2177 Diag(StartLoc, diag::warn_delete_array_type)
John Wiegley429bb272011-04-08 18:41:53 +00002178 << Type << Ex.get()->getSourceRange()
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00002179 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(StartLoc), "[]");
2180 ArrayForm = true;
2181 }
2182
Anders Carlssond67c4c32009-08-16 20:29:29 +00002183 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
2184 ArrayForm ? OO_Array_Delete : OO_Delete);
2185
Eli Friedmane52c9142011-07-26 22:25:31 +00002186 if (PointeeRD) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002187 if (!UseGlobal &&
Eli Friedmane52c9142011-07-26 22:25:31 +00002188 FindDeallocationFunction(StartLoc, PointeeRD, DeleteName,
2189 OperatorDelete))
Anders Carlsson0ba63ea2009-11-14 03:17:38 +00002190 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002191
John McCall6ec278d2011-01-27 09:37:56 +00002192 // If we're allocating an array of records, check whether the
2193 // usual operator delete[] has a size_t parameter.
2194 if (ArrayForm) {
2195 // If the user specifically asked to use the global allocator,
2196 // we'll need to do the lookup into the class.
2197 if (UseGlobal)
2198 UsualArrayDeleteWantsSize =
2199 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
2200
2201 // Otherwise, the usual operator delete[] should be the
2202 // function we just found.
2203 else if (isa<CXXMethodDecl>(OperatorDelete))
2204 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2);
2205 }
2206
Richard Smith213d70b2012-02-18 04:13:32 +00002207 if (!PointeeRD->hasIrrelevantDestructor())
Eli Friedmane52c9142011-07-26 22:25:31 +00002208 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00002209 MarkFunctionReferenced(StartLoc,
Fariborz Jahanian34374e62009-09-03 23:18:17 +00002210 const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith82f145d2013-05-04 06:44:46 +00002211 if (DiagnoseUseOfDecl(Dtor, StartLoc))
2212 return ExprError();
Douglas Gregor9b623632010-10-12 23:32:35 +00002213 }
Argyrios Kyrtzidis6f0074a2011-05-24 19:53:26 +00002214
2215 // C++ [expr.delete]p3:
2216 // In the first alternative (delete object), if the static type of the
2217 // object to be deleted is different from its dynamic type, the static
2218 // type shall be a base class of the dynamic type of the object to be
2219 // deleted and the static type shall have a virtual destructor or the
2220 // behavior is undefined.
2221 //
2222 // Note: a final class cannot be derived from, no issue there
Eli Friedmanef8c79c2011-07-26 23:27:24 +00002223 if (PointeeRD->isPolymorphic() && !PointeeRD->hasAttr<FinalAttr>()) {
Eli Friedmane52c9142011-07-26 22:25:31 +00002224 CXXDestructorDecl *dtor = PointeeRD->getDestructor();
Eli Friedmanef8c79c2011-07-26 23:27:24 +00002225 if (dtor && !dtor->isVirtual()) {
2226 if (PointeeRD->isAbstract()) {
2227 // If the class is abstract, we warn by default, because we're
2228 // sure the code has undefined behavior.
2229 Diag(StartLoc, diag::warn_delete_abstract_non_virtual_dtor)
2230 << PointeeElem;
2231 } else if (!ArrayForm) {
2232 // Otherwise, if this is not an array delete, it's a bit suspect,
2233 // but not necessarily wrong.
2234 Diag(StartLoc, diag::warn_delete_non_virtual_dtor) << PointeeElem;
2235 }
2236 }
Argyrios Kyrtzidis6f0074a2011-05-24 19:53:26 +00002237 }
John McCallf85e1932011-06-15 23:02:42 +00002238
Anders Carlssond67c4c32009-08-16 20:29:29 +00002239 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002240
Anders Carlssond67c4c32009-08-16 20:29:29 +00002241 if (!OperatorDelete) {
Anders Carlsson78f74552009-11-15 18:45:20 +00002242 // Look for a global declaration.
Anders Carlssond67c4c32009-08-16 20:29:29 +00002243 DeclareGlobalNewDelete();
2244 DeclContext *TUDecl = Context.getTranslationUnitDecl();
John Wiegley429bb272011-04-08 18:41:53 +00002245 Expr *Arg = Ex.get();
Abramo Bagnara34f60a42012-07-09 21:15:43 +00002246 if (!Context.hasSameType(Arg->getType(), Context.VoidPtrTy))
2247 Arg = ImplicitCastExpr::Create(Context, Context.VoidPtrTy,
2248 CK_BitCast, Arg, 0, VK_RValue);
Mike Stump1eb44332009-09-09 15:08:12 +00002249 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName,
John Wiegley429bb272011-04-08 18:41:53 +00002250 &Arg, 1, TUDecl, /*AllowMissing=*/false,
Anders Carlssond67c4c32009-08-16 20:29:29 +00002251 OperatorDelete))
2252 return ExprError();
2253 }
Mike Stump1eb44332009-09-09 15:08:12 +00002254
Eli Friedman5f2987c2012-02-02 03:46:19 +00002255 MarkFunctionReferenced(StartLoc, OperatorDelete);
John McCall6ec278d2011-01-27 09:37:56 +00002256
Douglas Gregord880f522011-02-01 15:50:11 +00002257 // Check access and ambiguity of operator delete and destructor.
Eli Friedmane52c9142011-07-26 22:25:31 +00002258 if (PointeeRD) {
2259 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
John Wiegley429bb272011-04-08 18:41:53 +00002260 CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
Douglas Gregord880f522011-02-01 15:50:11 +00002261 PDiag(diag::err_access_dtor) << PointeeElem);
2262 }
2263 }
2264
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002265 }
2266
Sebastian Redlf53597f2009-03-15 17:47:39 +00002267 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
John McCall6ec278d2011-01-27 09:37:56 +00002268 ArrayFormAsWritten,
2269 UsualArrayDeleteWantsSize,
John Wiegley429bb272011-04-08 18:41:53 +00002270 OperatorDelete, Ex.take(), StartLoc));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00002271}
2272
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002273/// \brief Check the use of the given variable as a C++ condition in an if,
2274/// while, do-while, or switch statement.
John McCall60d7b3a2010-08-24 06:29:42 +00002275ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
John McCallf89e55a2010-11-18 06:31:45 +00002276 SourceLocation StmtLoc,
2277 bool ConvertToBoolean) {
Richard Smithdc7a4f52013-04-30 13:56:41 +00002278 if (ConditionVar->isInvalidDecl())
2279 return ExprError();
2280
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002281 QualType T = ConditionVar->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002282
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002283 // C++ [stmt.select]p2:
2284 // The declarator shall not specify a function or an array.
2285 if (T->isFunctionType())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002286 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002287 diag::err_invalid_use_of_function_type)
2288 << ConditionVar->getSourceRange());
2289 else if (T->isArrayType())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002290 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002291 diag::err_invalid_use_of_array_type)
2292 << ConditionVar->getSourceRange());
Douglas Gregora7605db2009-11-24 16:07:02 +00002293
John Wiegley429bb272011-04-08 18:41:53 +00002294 ExprResult Condition =
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002295 Owned(DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
2296 SourceLocation(),
2297 ConditionVar,
John McCallf4b88a42012-03-10 09:33:50 +00002298 /*enclosing*/ false,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002299 ConditionVar->getLocation(),
2300 ConditionVar->getType().getNonReferenceType(),
John Wiegley429bb272011-04-08 18:41:53 +00002301 VK_LValue));
Eli Friedmancf7c14c2012-01-16 21:00:51 +00002302
Eli Friedman5f2987c2012-02-02 03:46:19 +00002303 MarkDeclRefReferenced(cast<DeclRefExpr>(Condition.get()));
Eli Friedmancf7c14c2012-01-16 21:00:51 +00002304
John Wiegley429bb272011-04-08 18:41:53 +00002305 if (ConvertToBoolean) {
2306 Condition = CheckBooleanCondition(Condition.take(), StmtLoc);
2307 if (Condition.isInvalid())
2308 return ExprError();
2309 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002310
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002311 return Condition;
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00002312}
2313
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002314/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
John Wiegley429bb272011-04-08 18:41:53 +00002315ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr) {
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002316 // C++ 6.4p4:
2317 // The value of a condition that is an initialized declaration in a statement
2318 // other than a switch statement is the value of the declared variable
2319 // implicitly converted to type bool. If that conversion is ill-formed, the
2320 // program is ill-formed.
2321 // The value of a condition that is an expression is the value of the
2322 // expression, implicitly converted to bool.
2323 //
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002324 return PerformContextuallyConvertToBool(CondExpr);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002325}
Douglas Gregor77a52232008-09-12 00:47:35 +00002326
2327/// Helper function to determine whether this is the (deprecated) C++
2328/// conversion from a string literal to a pointer to non-const char or
2329/// non-const wchar_t (for narrow and wide string literals,
2330/// respectively).
Mike Stump1eb44332009-09-09 15:08:12 +00002331bool
Douglas Gregor77a52232008-09-12 00:47:35 +00002332Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
2333 // Look inside the implicit cast, if it exists.
2334 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
2335 From = Cast->getSubExpr();
2336
2337 // A string literal (2.13.4) that is not a wide string literal can
2338 // be converted to an rvalue of type "pointer to char"; a wide
2339 // string literal can be converted to an rvalue of type "pointer
2340 // to wchar_t" (C++ 4.2p2).
Douglas Gregor1984eb92010-06-22 23:47:37 +00002341 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
Ted Kremenek6217b802009-07-29 21:53:49 +00002342 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
Mike Stump1eb44332009-09-09 15:08:12 +00002343 if (const BuiltinType *ToPointeeType
John McCall183700f2009-09-21 23:43:11 +00002344 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
Douglas Gregor77a52232008-09-12 00:47:35 +00002345 // This conversion is considered only when there is an
2346 // explicit appropriate pointer target type (C++ 4.2p2).
Douglas Gregor5cee1192011-07-27 05:40:30 +00002347 if (!ToPtrType->getPointeeType().hasQualifiers()) {
2348 switch (StrLit->getKind()) {
2349 case StringLiteral::UTF8:
2350 case StringLiteral::UTF16:
2351 case StringLiteral::UTF32:
2352 // We don't allow UTF literals to be implicitly converted
2353 break;
2354 case StringLiteral::Ascii:
2355 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
2356 ToPointeeType->getKind() == BuiltinType::Char_S);
2357 case StringLiteral::Wide:
2358 return ToPointeeType->isWideCharType();
2359 }
2360 }
Douglas Gregor77a52232008-09-12 00:47:35 +00002361 }
2362
2363 return false;
2364}
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002365
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002366static ExprResult BuildCXXCastArgument(Sema &S,
John McCall2de56d12010-08-25 11:45:40 +00002367 SourceLocation CastLoc,
2368 QualType Ty,
2369 CastKind Kind,
2370 CXXMethodDecl *Method,
John McCallca82a822011-09-21 08:36:56 +00002371 DeclAccessPair FoundDecl,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00002372 bool HadMultipleCandidates,
John McCall2de56d12010-08-25 11:45:40 +00002373 Expr *From) {
Douglas Gregorba70ab62010-04-16 22:17:36 +00002374 switch (Kind) {
David Blaikieb219cfc2011-09-23 05:06:16 +00002375 default: llvm_unreachable("Unhandled cast kind!");
John McCall2de56d12010-08-25 11:45:40 +00002376 case CK_ConstructorConversion: {
Douglas Gregor13e1bca2011-10-10 22:41:00 +00002377 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00002378 SmallVector<Expr*, 8> ConstructorArgs;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002379
Benjamin Kramer5354e772012-08-23 23:38:35 +00002380 if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00002381 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002382
John McCallb9abd8722012-04-07 03:04:20 +00002383 S.CheckConstructorAccess(CastLoc, Constructor,
2384 InitializedEntity::InitializeTemporary(Ty),
2385 Constructor->getAccess());
Richard Smithc83c2302012-12-19 01:39:02 +00002386
Douglas Gregor13e1bca2011-10-10 22:41:00 +00002387 ExprResult Result
2388 = S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method),
Richard Smithc83c2302012-12-19 01:39:02 +00002389 ConstructorArgs, HadMultipleCandidates,
2390 /*ListInit*/ false, /*ZeroInit*/ false,
Douglas Gregor13e1bca2011-10-10 22:41:00 +00002391 CXXConstructExpr::CK_Complete, SourceRange());
Douglas Gregorba70ab62010-04-16 22:17:36 +00002392 if (Result.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00002393 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002394
Douglas Gregorba70ab62010-04-16 22:17:36 +00002395 return S.MaybeBindToTemporary(Result.takeAs<Expr>());
2396 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002397
John McCall2de56d12010-08-25 11:45:40 +00002398 case CK_UserDefinedConversion: {
Douglas Gregorba70ab62010-04-16 22:17:36 +00002399 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002400
Douglas Gregorba70ab62010-04-16 22:17:36 +00002401 // Create an implicit call expr that calls it.
Eli Friedman3f01c8a2012-03-01 01:30:04 +00002402 CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
2403 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00002404 HadMultipleCandidates);
Douglas Gregorf2ae5262011-01-20 00:18:04 +00002405 if (Result.isInvalid())
2406 return ExprError();
Abramo Bagnara960809e2011-11-16 22:46:05 +00002407 // Record usage of conversion in an implicit cast.
2408 Result = S.Owned(ImplicitCastExpr::Create(S.Context,
2409 Result.get()->getType(),
2410 CK_UserDefinedConversion,
2411 Result.get(), 0,
2412 Result.get()->getValueKind()));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002413
John McCallca82a822011-09-21 08:36:56 +00002414 S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ 0, FoundDecl);
2415
Douglas Gregorf2ae5262011-01-20 00:18:04 +00002416 return S.MaybeBindToTemporary(Result.get());
Douglas Gregorba70ab62010-04-16 22:17:36 +00002417 }
2418 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002419}
Douglas Gregorba70ab62010-04-16 22:17:36 +00002420
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002421/// PerformImplicitConversion - Perform an implicit conversion of the
2422/// expression From to the type ToType using the pre-computed implicit
John Wiegley429bb272011-04-08 18:41:53 +00002423/// conversion sequence ICS. Returns the converted
Douglas Gregor68647482009-12-16 03:45:30 +00002424/// expression. Action is the kind of conversion we're performing,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002425/// used in the error message.
John Wiegley429bb272011-04-08 18:41:53 +00002426ExprResult
2427Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002428 const ImplicitConversionSequence &ICS,
John McCallf85e1932011-06-15 23:02:42 +00002429 AssignmentAction Action,
2430 CheckedConversionKind CCK) {
John McCall1d318332010-01-12 00:44:57 +00002431 switch (ICS.getKind()) {
John Wiegley429bb272011-04-08 18:41:53 +00002432 case ImplicitConversionSequence::StandardConversion: {
Richard Smithc8d7f582011-11-29 22:48:16 +00002433 ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
2434 Action, CCK);
John Wiegley429bb272011-04-08 18:41:53 +00002435 if (Res.isInvalid())
2436 return ExprError();
2437 From = Res.take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002438 break;
John Wiegley429bb272011-04-08 18:41:53 +00002439 }
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002440
Anders Carlssonf6c213a2009-09-15 06:28:28 +00002441 case ImplicitConversionSequence::UserDefinedConversion: {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002442
Fariborz Jahanian7fe5d722009-08-28 22:04:50 +00002443 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
John McCalldaa8e4e2010-11-15 09:13:47 +00002444 CastKind CastKind;
Anders Carlssonf6c213a2009-09-15 06:28:28 +00002445 QualType BeforeToType;
Sebastian Redlcc7a6482011-11-01 15:53:09 +00002446 assert(FD && "FIXME: aggregate initialization from init list");
Anders Carlssonf6c213a2009-09-15 06:28:28 +00002447 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
John McCall2de56d12010-08-25 11:45:40 +00002448 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002449
Anders Carlssonf6c213a2009-09-15 06:28:28 +00002450 // If the user-defined conversion is specified by a conversion function,
2451 // the initial standard conversion sequence converts the source type to
2452 // the implicit object parameter of the conversion function.
2453 BeforeToType = Context.getTagDeclType(Conv->getParent());
John McCall9ec94452010-12-04 09:57:16 +00002454 } else {
2455 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
John McCall2de56d12010-08-25 11:45:40 +00002456 CastKind = CK_ConstructorConversion;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002457 // Do no conversion if dealing with ... for the first conversion.
Douglas Gregore44201a2009-11-20 02:31:03 +00002458 if (!ICS.UserDefined.EllipsisConversion) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002459 // If the user-defined conversion is specified by a constructor, the
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002460 // initial standard conversion sequence converts the source type to the
2461 // type required by the argument of the constructor
Douglas Gregore44201a2009-11-20 02:31:03 +00002462 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
2463 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002464 }
Douglas Gregora3998bd2010-12-02 21:47:04 +00002465 // Watch out for elipsis conversion.
Fariborz Jahanian4c0cea22009-11-06 00:55:14 +00002466 if (!ICS.UserDefined.EllipsisConversion) {
John Wiegley429bb272011-04-08 18:41:53 +00002467 ExprResult Res =
Richard Smithc8d7f582011-11-29 22:48:16 +00002468 PerformImplicitConversion(From, BeforeToType,
2469 ICS.UserDefined.Before, AA_Converting,
2470 CCK);
John Wiegley429bb272011-04-08 18:41:53 +00002471 if (Res.isInvalid())
2472 return ExprError();
2473 From = Res.take();
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002474 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002475
2476 ExprResult CastArg
Douglas Gregorba70ab62010-04-16 22:17:36 +00002477 = BuildCXXCastArgument(*this,
2478 From->getLocStart(),
Anders Carlsson0aebc812009-09-09 21:33:21 +00002479 ToType.getNonReferenceType(),
Douglas Gregor83eecbe2011-01-20 01:32:05 +00002480 CastKind, cast<CXXMethodDecl>(FD),
2481 ICS.UserDefined.FoundConversionFunction,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00002482 ICS.UserDefined.HadMultipleCandidates,
John McCall9ae2f072010-08-23 23:25:46 +00002483 From);
Anders Carlsson0aebc812009-09-09 21:33:21 +00002484
2485 if (CastArg.isInvalid())
John Wiegley429bb272011-04-08 18:41:53 +00002486 return ExprError();
Eli Friedmand8889622009-11-27 04:41:50 +00002487
John Wiegley429bb272011-04-08 18:41:53 +00002488 From = CastArg.take();
Eli Friedmand8889622009-11-27 04:41:50 +00002489
Richard Smithc8d7f582011-11-29 22:48:16 +00002490 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
2491 AA_Converting, CCK);
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00002492 }
John McCall1d318332010-01-12 00:44:57 +00002493
2494 case ImplicitConversionSequence::AmbiguousConversion:
John McCall120d63c2010-08-24 20:38:10 +00002495 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
John McCall1d318332010-01-12 00:44:57 +00002496 PDiag(diag::err_typecheck_ambiguous_condition)
2497 << From->getSourceRange());
John Wiegley429bb272011-04-08 18:41:53 +00002498 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002499
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002500 case ImplicitConversionSequence::EllipsisConversion:
David Blaikieb219cfc2011-09-23 05:06:16 +00002501 llvm_unreachable("Cannot perform an ellipsis conversion");
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002502
2503 case ImplicitConversionSequence::BadConversion:
John Wiegley429bb272011-04-08 18:41:53 +00002504 return ExprError();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002505 }
2506
2507 // Everything went well.
John Wiegley429bb272011-04-08 18:41:53 +00002508 return Owned(From);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002509}
2510
Richard Smithc8d7f582011-11-29 22:48:16 +00002511/// PerformImplicitConversion - Perform an implicit conversion of the
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002512/// expression From to the type ToType by following the standard
John Wiegley429bb272011-04-08 18:41:53 +00002513/// conversion sequence SCS. Returns the converted
Douglas Gregor45920e82008-12-19 17:40:08 +00002514/// expression. Flavor is the context in which we're performing this
2515/// conversion, for use in error messages.
John Wiegley429bb272011-04-08 18:41:53 +00002516ExprResult
Richard Smithc8d7f582011-11-29 22:48:16 +00002517Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00002518 const StandardConversionSequence& SCS,
John McCallf85e1932011-06-15 23:02:42 +00002519 AssignmentAction Action,
2520 CheckedConversionKind CCK) {
2521 bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast);
2522
Mike Stump390b4cc2009-05-16 07:39:55 +00002523 // Overall FIXME: we are recomputing too many types here and doing far too
2524 // much extra work. What this means is that we need to keep track of more
2525 // information that is computed when we try the implicit conversion initially,
2526 // so that we don't need to recompute anything here.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002527 QualType FromType = From->getType();
John McCallf85e1932011-06-15 23:02:42 +00002528
Douglas Gregor225c41e2008-11-03 19:09:14 +00002529 if (SCS.CopyConstructor) {
Anders Carlsson7c3e8a12009-05-19 04:45:15 +00002530 // FIXME: When can ToType be a reference type?
2531 assert(!ToType->isReferenceType());
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002532 if (SCS.Second == ICK_Derived_To_Base) {
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00002533 SmallVector<Expr*, 8> ConstructorArgs;
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002534 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
Benjamin Kramer5354e772012-08-23 23:38:35 +00002535 From, /*FIXME:ConstructLoc*/SourceLocation(),
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002536 ConstructorArgs))
John Wiegley429bb272011-04-08 18:41:53 +00002537 return ExprError();
2538 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2539 ToType, SCS.CopyConstructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00002540 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00002541 /*HadMultipleCandidates*/ false,
Richard Smithc83c2302012-12-19 01:39:02 +00002542 /*ListInit*/ false, /*ZeroInit*/ false,
John Wiegley429bb272011-04-08 18:41:53 +00002543 CXXConstructExpr::CK_Complete,
2544 SourceRange());
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002545 }
John Wiegley429bb272011-04-08 18:41:53 +00002546 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2547 ToType, SCS.CopyConstructor,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002548 From, /*HadMultipleCandidates*/ false,
Richard Smithc83c2302012-12-19 01:39:02 +00002549 /*ListInit*/ false, /*ZeroInit*/ false,
John Wiegley429bb272011-04-08 18:41:53 +00002550 CXXConstructExpr::CK_Complete,
2551 SourceRange());
Douglas Gregor225c41e2008-11-03 19:09:14 +00002552 }
2553
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002554 // Resolve overloaded function references.
2555 if (Context.hasSameType(FromType, Context.OverloadTy)) {
2556 DeclAccessPair Found;
2557 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
2558 true, Found);
2559 if (!Fn)
John Wiegley429bb272011-04-08 18:41:53 +00002560 return ExprError();
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002561
Daniel Dunbar96a00142012-03-09 18:35:03 +00002562 if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
John Wiegley429bb272011-04-08 18:41:53 +00002563 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002564
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002565 From = FixOverloadedFunctionReference(From, Found, Fn);
2566 FromType = From->getType();
2567 }
2568
Richard Smithc8d7f582011-11-29 22:48:16 +00002569 // Perform the first implicit conversion.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002570 switch (SCS.First) {
2571 case ICK_Identity:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002572 // Nothing to do.
2573 break;
2574
Eli Friedmand814eaf2012-01-24 22:51:26 +00002575 case ICK_Lvalue_To_Rvalue: {
John McCall3c3b7f92011-10-25 17:37:35 +00002576 assert(From->getObjectKind() != OK_ObjCProperty);
John McCallf6a16482010-12-04 03:47:34 +00002577 FromType = FromType.getUnqualifiedType();
Eli Friedmand814eaf2012-01-24 22:51:26 +00002578 ExprResult FromRes = DefaultLvalueConversion(From);
2579 assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
2580 From = FromRes.take();
John McCallf6a16482010-12-04 03:47:34 +00002581 break;
Eli Friedmand814eaf2012-01-24 22:51:26 +00002582 }
John McCallf6a16482010-12-04 03:47:34 +00002583
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002584 case ICK_Array_To_Pointer:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002585 FromType = Context.getArrayDecayedType(FromType);
Richard Smithc8d7f582011-11-29 22:48:16 +00002586 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
2587 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002588 break;
2589
2590 case ICK_Function_To_Pointer:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002591 FromType = Context.getPointerType(FromType);
Richard Smithc8d7f582011-11-29 22:48:16 +00002592 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
2593 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002594 break;
2595
2596 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00002597 llvm_unreachable("Improper first standard conversion");
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002598 }
2599
Richard Smithc8d7f582011-11-29 22:48:16 +00002600 // Perform the second implicit conversion
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002601 switch (SCS.Second) {
2602 case ICK_Identity:
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002603 // If both sides are functions (or pointers/references to them), there could
2604 // be incompatible exception declarations.
2605 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002606 return ExprError();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002607 // Nothing else to do.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002608 break;
2609
Douglas Gregor43c79c22009-12-09 00:47:37 +00002610 case ICK_NoReturn_Adjustment:
2611 // If both sides are functions (or pointers/references to them), there could
2612 // be incompatible exception declarations.
2613 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002614 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002615
Richard Smithc8d7f582011-11-29 22:48:16 +00002616 From = ImpCastExprToType(From, ToType, CK_NoOp,
2617 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregor43c79c22009-12-09 00:47:37 +00002618 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002619
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002620 case ICK_Integral_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002621 case ICK_Integral_Conversion:
Richard Smithe7ff9192012-09-13 21:18:54 +00002622 if (ToType->isBooleanType()) {
2623 assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
2624 SCS.Second == ICK_Integral_Promotion &&
2625 "only enums with fixed underlying type can promote to bool");
2626 From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
2627 VK_RValue, /*BasePath=*/0, CCK).take();
2628 } else {
2629 From = ImpCastExprToType(From, ToType, CK_IntegralCast,
2630 VK_RValue, /*BasePath=*/0, CCK).take();
2631 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00002632 break;
2633
2634 case ICK_Floating_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002635 case ICK_Floating_Conversion:
Richard Smithc8d7f582011-11-29 22:48:16 +00002636 From = ImpCastExprToType(From, ToType, CK_FloatingCast,
2637 VK_RValue, /*BasePath=*/0, CCK).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002638 break;
2639
2640 case ICK_Complex_Promotion:
John McCalldaa8e4e2010-11-15 09:13:47 +00002641 case ICK_Complex_Conversion: {
2642 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
2643 QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
2644 CastKind CK;
2645 if (FromEl->isRealFloatingType()) {
2646 if (ToEl->isRealFloatingType())
2647 CK = CK_FloatingComplexCast;
2648 else
2649 CK = CK_FloatingComplexToIntegralComplex;
2650 } else if (ToEl->isRealFloatingType()) {
2651 CK = CK_IntegralComplexToFloatingComplex;
2652 } else {
2653 CK = CK_IntegralComplexCast;
2654 }
Richard Smithc8d7f582011-11-29 22:48:16 +00002655 From = ImpCastExprToType(From, ToType, CK,
2656 VK_RValue, /*BasePath=*/0, CCK).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002657 break;
John McCalldaa8e4e2010-11-15 09:13:47 +00002658 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00002659
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002660 case ICK_Floating_Integral:
Douglas Gregor0c293ea2010-06-22 23:07:26 +00002661 if (ToType->isRealFloatingType())
Richard Smithc8d7f582011-11-29 22:48:16 +00002662 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
2663 VK_RValue, /*BasePath=*/0, CCK).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002664 else
Richard Smithc8d7f582011-11-29 22:48:16 +00002665 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
2666 VK_RValue, /*BasePath=*/0, CCK).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002667 break;
2668
Douglas Gregorf9201e02009-02-11 23:02:49 +00002669 case ICK_Compatible_Conversion:
Richard Smithc8d7f582011-11-29 22:48:16 +00002670 From = ImpCastExprToType(From, ToType, CK_NoOp,
2671 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002672 break;
2673
John McCallf85e1932011-06-15 23:02:42 +00002674 case ICK_Writeback_Conversion:
Anders Carlsson61faec12009-09-12 04:46:44 +00002675 case ICK_Pointer_Conversion: {
Douglas Gregora3998bd2010-12-02 21:47:04 +00002676 if (SCS.IncompatibleObjC && Action != AA_Casting) {
Douglas Gregor45920e82008-12-19 17:40:08 +00002677 // Diagnose incompatible Objective-C conversions
Douglas Gregor8cf0d222011-06-11 04:42:12 +00002678 if (Action == AA_Initializing || Action == AA_Assigning)
Daniel Dunbar96a00142012-03-09 18:35:03 +00002679 Diag(From->getLocStart(),
Fariborz Jahanian84950c72011-03-21 19:08:42 +00002680 diag::ext_typecheck_convert_incompatible_pointer)
2681 << ToType << From->getType() << Action
Anna Zaks67221552011-07-28 19:51:27 +00002682 << From->getSourceRange() << 0;
Fariborz Jahanian84950c72011-03-21 19:08:42 +00002683 else
Daniel Dunbar96a00142012-03-09 18:35:03 +00002684 Diag(From->getLocStart(),
Fariborz Jahanian84950c72011-03-21 19:08:42 +00002685 diag::ext_typecheck_convert_incompatible_pointer)
2686 << From->getType() << ToType << Action
Anna Zaks67221552011-07-28 19:51:27 +00002687 << From->getSourceRange() << 0;
John McCallf85e1932011-06-15 23:02:42 +00002688
Douglas Gregor926df6c2011-06-11 01:09:30 +00002689 if (From->getType()->isObjCObjectPointerType() &&
2690 ToType->isObjCObjectPointerType())
2691 EmitRelatedResultTypeNote(From);
Fariborz Jahanian82007c32011-07-08 17:41:42 +00002692 }
David Blaikie4e4d0842012-03-11 07:00:24 +00002693 else if (getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanian82007c32011-07-08 17:41:42 +00002694 !CheckObjCARCUnavailableWeakConversion(ToType,
2695 From->getType())) {
John McCall7f3a6d32011-09-09 06:12:06 +00002696 if (Action == AA_Initializing)
Daniel Dunbar96a00142012-03-09 18:35:03 +00002697 Diag(From->getLocStart(),
John McCall7f3a6d32011-09-09 06:12:06 +00002698 diag::err_arc_weak_unavailable_assign);
2699 else
Daniel Dunbar96a00142012-03-09 18:35:03 +00002700 Diag(From->getLocStart(),
John McCall7f3a6d32011-09-09 06:12:06 +00002701 diag::err_arc_convesion_of_weak_unavailable)
2702 << (Action == AA_Casting) << From->getType() << ToType
2703 << From->getSourceRange();
2704 }
Fariborz Jahanian82007c32011-07-08 17:41:42 +00002705
John McCalldaa8e4e2010-11-15 09:13:47 +00002706 CastKind Kind = CK_Invalid;
John McCallf871d0c2010-08-07 06:22:56 +00002707 CXXCastPath BasePath;
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002708 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002709 return ExprError();
John McCalldc05b112011-09-10 01:16:55 +00002710
2711 // Make sure we extend blocks if necessary.
2712 // FIXME: doing this here is really ugly.
2713 if (Kind == CK_BlockPointerToObjCPointerCast) {
2714 ExprResult E = From;
2715 (void) PrepareCastToObjCObjectPointer(E);
2716 From = E.take();
2717 }
2718
Richard Smithc8d7f582011-11-29 22:48:16 +00002719 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
2720 .take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002721 break;
Anders Carlsson61faec12009-09-12 04:46:44 +00002722 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002723
Anders Carlsson61faec12009-09-12 04:46:44 +00002724 case ICK_Pointer_Member: {
John McCalldaa8e4e2010-11-15 09:13:47 +00002725 CastKind Kind = CK_Invalid;
John McCallf871d0c2010-08-07 06:22:56 +00002726 CXXCastPath BasePath;
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002727 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002728 return ExprError();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002729 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002730 return ExprError();
Richard Smithc8d7f582011-11-29 22:48:16 +00002731 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
2732 .take();
Anders Carlsson61faec12009-09-12 04:46:44 +00002733 break;
2734 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002735
Abramo Bagnara737d5442011-04-07 09:26:19 +00002736 case ICK_Boolean_Conversion:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00002737 // Perform half-to-boolean conversion via float.
2738 if (From->getType()->isHalfType()) {
2739 From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).take();
2740 FromType = Context.FloatTy;
2741 }
2742
Richard Smithc8d7f582011-11-29 22:48:16 +00002743 From = ImpCastExprToType(From, Context.BoolTy,
2744 ScalarTypeToBooleanCastKind(FromType),
2745 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002746 break;
2747
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002748 case ICK_Derived_To_Base: {
John McCallf871d0c2010-08-07 06:22:56 +00002749 CXXCastPath BasePath;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002750 if (CheckDerivedToBaseConversion(From->getType(),
Douglas Gregorb7a86f52009-11-06 01:02:41 +00002751 ToType.getNonReferenceType(),
2752 From->getLocStart(),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002753 From->getSourceRange(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002754 &BasePath,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002755 CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002756 return ExprError();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002757
Richard Smithc8d7f582011-11-29 22:48:16 +00002758 From = ImpCastExprToType(From, ToType.getNonReferenceType(),
2759 CK_DerivedToBase, From->getValueKind(),
2760 &BasePath, CCK).take();
Douglas Gregorb7a86f52009-11-06 01:02:41 +00002761 break;
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002762 }
2763
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002764 case ICK_Vector_Conversion:
Richard Smithc8d7f582011-11-29 22:48:16 +00002765 From = ImpCastExprToType(From, ToType, CK_BitCast,
2766 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002767 break;
2768
2769 case ICK_Vector_Splat:
Richard Smithc8d7f582011-11-29 22:48:16 +00002770 From = ImpCastExprToType(From, ToType, CK_VectorSplat,
2771 VK_RValue, /*BasePath=*/0, CCK).take();
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002772 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002773
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002774 case ICK_Complex_Real:
John McCalldaa8e4e2010-11-15 09:13:47 +00002775 // Case 1. x -> _Complex y
2776 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
2777 QualType ElType = ToComplex->getElementType();
2778 bool isFloatingComplex = ElType->isRealFloatingType();
2779
2780 // x -> y
2781 if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
2782 // do nothing
2783 } else if (From->getType()->isRealFloatingType()) {
Richard Smithc8d7f582011-11-29 22:48:16 +00002784 From = ImpCastExprToType(From, ElType,
2785 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002786 } else {
2787 assert(From->getType()->isIntegerType());
Richard Smithc8d7f582011-11-29 22:48:16 +00002788 From = ImpCastExprToType(From, ElType,
2789 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002790 }
2791 // y -> _Complex y
Richard Smithc8d7f582011-11-29 22:48:16 +00002792 From = ImpCastExprToType(From, ToType,
2793 isFloatingComplex ? CK_FloatingRealToComplex
2794 : CK_IntegralRealToComplex).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002795
2796 // Case 2. _Complex x -> y
2797 } else {
2798 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
2799 assert(FromComplex);
2800
2801 QualType ElType = FromComplex->getElementType();
2802 bool isFloatingComplex = ElType->isRealFloatingType();
2803
2804 // _Complex x -> x
Richard Smithc8d7f582011-11-29 22:48:16 +00002805 From = ImpCastExprToType(From, ElType,
2806 isFloatingComplex ? CK_FloatingComplexToReal
2807 : CK_IntegralComplexToReal,
2808 VK_RValue, /*BasePath=*/0, CCK).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002809
2810 // x -> y
2811 if (Context.hasSameUnqualifiedType(ElType, ToType)) {
2812 // do nothing
2813 } else if (ToType->isRealFloatingType()) {
Richard Smithc8d7f582011-11-29 22:48:16 +00002814 From = ImpCastExprToType(From, ToType,
2815 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
2816 VK_RValue, /*BasePath=*/0, CCK).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002817 } else {
2818 assert(ToType->isIntegerType());
Richard Smithc8d7f582011-11-29 22:48:16 +00002819 From = ImpCastExprToType(From, ToType,
2820 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
2821 VK_RValue, /*BasePath=*/0, CCK).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002822 }
2823 }
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002824 break;
Fariborz Jahaniane3c8c642011-02-12 19:07:46 +00002825
2826 case ICK_Block_Pointer_Conversion: {
Richard Smithc8d7f582011-11-29 22:48:16 +00002827 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
2828 VK_RValue, /*BasePath=*/0, CCK).take();
John McCallf85e1932011-06-15 23:02:42 +00002829 break;
2830 }
Fariborz Jahaniane3c8c642011-02-12 19:07:46 +00002831
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002832 case ICK_TransparentUnionConversion: {
John Wiegley429bb272011-04-08 18:41:53 +00002833 ExprResult FromRes = Owned(From);
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002834 Sema::AssignConvertType ConvTy =
John Wiegley429bb272011-04-08 18:41:53 +00002835 CheckTransparentUnionArgumentConstraints(ToType, FromRes);
2836 if (FromRes.isInvalid())
2837 return ExprError();
2838 From = FromRes.take();
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002839 assert ((ConvTy == Sema::Compatible) &&
2840 "Improper transparent union conversion");
2841 (void)ConvTy;
2842 break;
2843 }
2844
Guy Benyei6959acd2013-02-07 16:05:33 +00002845 case ICK_Zero_Event_Conversion:
2846 From = ImpCastExprToType(From, ToType,
2847 CK_ZeroToOCLEvent,
2848 From->getValueKind()).take();
2849 break;
2850
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002851 case ICK_Lvalue_To_Rvalue:
2852 case ICK_Array_To_Pointer:
2853 case ICK_Function_To_Pointer:
2854 case ICK_Qualification:
2855 case ICK_Num_Conversion_Kinds:
David Blaikieb219cfc2011-09-23 05:06:16 +00002856 llvm_unreachable("Improper second standard conversion");
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002857 }
2858
2859 switch (SCS.Third) {
2860 case ICK_Identity:
2861 // Nothing to do.
2862 break;
2863
Sebastian Redl906082e2010-07-20 04:20:21 +00002864 case ICK_Qualification: {
2865 // The qualification keeps the category of the inner expression, unless the
2866 // target type isn't a reference.
John McCall5baba9d2010-08-25 10:28:54 +00002867 ExprValueKind VK = ToType->isReferenceType() ?
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00002868 From->getValueKind() : VK_RValue;
Richard Smithc8d7f582011-11-29 22:48:16 +00002869 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
2870 CK_NoOp, VK, /*BasePath=*/0, CCK).take();
Douglas Gregora9bff302010-02-28 18:30:25 +00002871
Douglas Gregor069a6da2011-03-14 16:13:32 +00002872 if (SCS.DeprecatedStringLiteralToCharPtr &&
David Blaikie4e4d0842012-03-11 07:00:24 +00002873 !getLangOpts().WritableStrings)
Douglas Gregora9bff302010-02-28 18:30:25 +00002874 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion)
2875 << ToType.getNonReferenceType();
2876
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002877 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002878 }
2879
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002880 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00002881 llvm_unreachable("Improper third standard conversion");
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002882 }
2883
Douglas Gregor47bfcca2012-04-12 20:42:30 +00002884 // If this conversion sequence involved a scalar -> atomic conversion, perform
2885 // that conversion now.
2886 if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>())
2887 if (Context.hasSameType(ToAtomic->getValueType(), From->getType()))
2888 From = ImpCastExprToType(From, ToType, CK_NonAtomicToAtomic, VK_RValue, 0,
2889 CCK).take();
2890
John Wiegley429bb272011-04-08 18:41:53 +00002891 return Owned(From);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002892}
2893
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002894ExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT,
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002895 SourceLocation KWLoc,
2896 ParsedType Ty,
2897 SourceLocation RParen) {
2898 TypeSourceInfo *TSInfo;
2899 QualType T = GetTypeFromParser(Ty, &TSInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00002900
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002901 if (!TSInfo)
2902 TSInfo = Context.getTrivialTypeSourceInfo(T);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002903 return BuildUnaryTypeTrait(UTT, KWLoc, TSInfo, RParen);
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002904}
2905
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002906/// \brief Check the completeness of a type in a unary type trait.
2907///
2908/// If the particular type trait requires a complete type, tries to complete
2909/// it. If completing the type fails, a diagnostic is emitted and false
2910/// returned. If completing the type succeeds or no completion was required,
2911/// returns true.
2912static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S,
2913 UnaryTypeTrait UTT,
2914 SourceLocation Loc,
2915 QualType ArgTy) {
2916 // C++0x [meta.unary.prop]p3:
2917 // For all of the class templates X declared in this Clause, instantiating
2918 // that template with a template argument that is a class template
2919 // specialization may result in the implicit instantiation of the template
2920 // argument if and only if the semantics of X require that the argument
2921 // must be a complete type.
2922 // We apply this rule to all the type trait expressions used to implement
2923 // these class templates. We also try to follow any GCC documented behavior
2924 // in these expressions to ensure portability of standard libraries.
2925 switch (UTT) {
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002926 // is_complete_type somewhat obviously cannot require a complete type.
2927 case UTT_IsCompleteType:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002928 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002929
2930 // These traits are modeled on the type predicates in C++0x
2931 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
2932 // requiring a complete type, as whether or not they return true cannot be
2933 // impacted by the completeness of the type.
2934 case UTT_IsVoid:
2935 case UTT_IsIntegral:
2936 case UTT_IsFloatingPoint:
2937 case UTT_IsArray:
2938 case UTT_IsPointer:
2939 case UTT_IsLvalueReference:
2940 case UTT_IsRvalueReference:
2941 case UTT_IsMemberFunctionPointer:
2942 case UTT_IsMemberObjectPointer:
2943 case UTT_IsEnum:
2944 case UTT_IsUnion:
2945 case UTT_IsClass:
2946 case UTT_IsFunction:
2947 case UTT_IsReference:
2948 case UTT_IsArithmetic:
2949 case UTT_IsFundamental:
2950 case UTT_IsObject:
2951 case UTT_IsScalar:
2952 case UTT_IsCompound:
2953 case UTT_IsMemberPointer:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002954 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002955
2956 // These traits are modeled on type predicates in C++0x [meta.unary.prop]
2957 // which requires some of its traits to have the complete type. However,
2958 // the completeness of the type cannot impact these traits' semantics, and
2959 // so they don't require it. This matches the comments on these traits in
2960 // Table 49.
2961 case UTT_IsConst:
2962 case UTT_IsVolatile:
2963 case UTT_IsSigned:
2964 case UTT_IsUnsigned:
2965 return true;
2966
2967 // C++0x [meta.unary.prop] Table 49 requires the following traits to be
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002968 // applied to a complete type.
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002969 case UTT_IsTrivial:
Sean Huntfeb375d2011-05-13 00:31:07 +00002970 case UTT_IsTriviallyCopyable:
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002971 case UTT_IsStandardLayout:
2972 case UTT_IsPOD:
2973 case UTT_IsLiteral:
2974 case UTT_IsEmpty:
2975 case UTT_IsPolymorphic:
2976 case UTT_IsAbstract:
John McCallea30e2f2012-09-25 07:32:49 +00002977 case UTT_IsInterfaceClass:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002978 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002979
Douglas Gregor5e9392b2011-12-03 18:14:24 +00002980 // These traits require a complete type.
2981 case UTT_IsFinal:
2982
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002983 // These trait expressions are designed to help implement predicates in
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002984 // [meta.unary.prop] despite not being named the same. They are specified
2985 // by both GCC and the Embarcadero C++ compiler, and require the complete
2986 // type due to the overarching C++0x type predicates being implemented
2987 // requiring the complete type.
2988 case UTT_HasNothrowAssign:
Joao Matos9ef98752013-03-27 01:34:16 +00002989 case UTT_HasNothrowMoveAssign:
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002990 case UTT_HasNothrowConstructor:
2991 case UTT_HasNothrowCopy:
2992 case UTT_HasTrivialAssign:
Joao Matos9ef98752013-03-27 01:34:16 +00002993 case UTT_HasTrivialMoveAssign:
Sean Hunt023df372011-05-09 18:22:59 +00002994 case UTT_HasTrivialDefaultConstructor:
Joao Matos9ef98752013-03-27 01:34:16 +00002995 case UTT_HasTrivialMoveConstructor:
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002996 case UTT_HasTrivialCopy:
2997 case UTT_HasTrivialDestructor:
2998 case UTT_HasVirtualDestructor:
2999 // Arrays of unknown bound are expressly allowed.
3000 QualType ElTy = ArgTy;
3001 if (ArgTy->isIncompleteArrayType())
3002 ElTy = S.Context.getAsArrayType(ArgTy)->getElementType();
3003
3004 // The void type is expressly allowed.
3005 if (ElTy->isVoidType())
3006 return true;
3007
3008 return !S.RequireCompleteType(
3009 Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
John Wiegleycf566412011-04-28 02:06:46 +00003010 }
Chandler Carruth73e0a912011-05-01 07:23:17 +00003011 llvm_unreachable("Type trait not handled by switch");
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00003012}
3013
Joao Matos9ef98752013-03-27 01:34:16 +00003014static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op,
3015 Sema &Self, SourceLocation KeyLoc, ASTContext &C,
3016 bool (CXXRecordDecl::*HasTrivial)() const,
3017 bool (CXXRecordDecl::*HasNonTrivial)() const,
3018 bool (CXXMethodDecl::*IsDesiredOp)() const)
3019{
3020 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
3021 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
3022 return true;
3023
3024 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(Op);
3025 DeclarationNameInfo NameInfo(Name, KeyLoc);
3026 LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName);
3027 if (Self.LookupQualifiedName(Res, RD)) {
3028 bool FoundOperator = false;
3029 Res.suppressDiagnostics();
3030 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
3031 Op != OpEnd; ++Op) {
3032 if (isa<FunctionTemplateDecl>(*Op))
3033 continue;
3034
3035 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3036 if((Operator->*IsDesiredOp)()) {
3037 FoundOperator = true;
3038 const FunctionProtoType *CPT =
3039 Operator->getType()->getAs<FunctionProtoType>();
3040 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3041 if (!CPT || !CPT->isNothrow(Self.Context))
3042 return false;
3043 }
3044 }
3045 return FoundOperator;
3046 }
3047 return false;
3048}
3049
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00003050static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT,
3051 SourceLocation KeyLoc, QualType T) {
Chandler Carruthd064c702011-05-01 08:41:10 +00003052 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegleycf566412011-04-28 02:06:46 +00003053
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003054 ASTContext &C = Self.Context;
3055 switch(UTT) {
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003056 // Type trait expressions corresponding to the primary type category
3057 // predicates in C++0x [meta.unary.cat].
3058 case UTT_IsVoid:
3059 return T->isVoidType();
3060 case UTT_IsIntegral:
3061 return T->isIntegralType(C);
3062 case UTT_IsFloatingPoint:
3063 return T->isFloatingType();
3064 case UTT_IsArray:
3065 return T->isArrayType();
3066 case UTT_IsPointer:
3067 return T->isPointerType();
3068 case UTT_IsLvalueReference:
3069 return T->isLValueReferenceType();
3070 case UTT_IsRvalueReference:
3071 return T->isRValueReferenceType();
3072 case UTT_IsMemberFunctionPointer:
3073 return T->isMemberFunctionPointerType();
3074 case UTT_IsMemberObjectPointer:
3075 return T->isMemberDataPointerType();
3076 case UTT_IsEnum:
3077 return T->isEnumeralType();
Chandler Carruth28eeb382011-05-01 06:11:03 +00003078 case UTT_IsUnion:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00003079 return T->isUnionType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003080 case UTT_IsClass:
Joao Matos6666ed42012-08-31 18:45:21 +00003081 return T->isClassType() || T->isStructureType() || T->isInterfaceType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003082 case UTT_IsFunction:
3083 return T->isFunctionType();
3084
3085 // Type trait expressions which correspond to the convenient composition
3086 // predicates in C++0x [meta.unary.comp].
3087 case UTT_IsReference:
3088 return T->isReferenceType();
3089 case UTT_IsArithmetic:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00003090 return T->isArithmeticType() && !T->isEnumeralType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003091 case UTT_IsFundamental:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00003092 return T->isFundamentalType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003093 case UTT_IsObject:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00003094 return T->isObjectType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003095 case UTT_IsScalar:
John McCallf85e1932011-06-15 23:02:42 +00003096 // Note: semantic analysis depends on Objective-C lifetime types to be
3097 // considered scalar types. However, such types do not actually behave
3098 // like scalar types at run time (since they may require retain/release
3099 // operations), so we report them as non-scalar.
3100 if (T->isObjCLifetimeType()) {
3101 switch (T.getObjCLifetime()) {
3102 case Qualifiers::OCL_None:
3103 case Qualifiers::OCL_ExplicitNone:
3104 return true;
3105
3106 case Qualifiers::OCL_Strong:
3107 case Qualifiers::OCL_Weak:
3108 case Qualifiers::OCL_Autoreleasing:
3109 return false;
3110 }
3111 }
3112
Chandler Carruthcec0ced2011-05-01 09:29:55 +00003113 return T->isScalarType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003114 case UTT_IsCompound:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00003115 return T->isCompoundType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003116 case UTT_IsMemberPointer:
3117 return T->isMemberPointerType();
3118
3119 // Type trait expressions which correspond to the type property predicates
3120 // in C++0x [meta.unary.prop].
3121 case UTT_IsConst:
3122 return T.isConstQualified();
3123 case UTT_IsVolatile:
3124 return T.isVolatileQualified();
3125 case UTT_IsTrivial:
John McCallf85e1932011-06-15 23:02:42 +00003126 return T.isTrivialType(Self.Context);
Sean Huntfeb375d2011-05-13 00:31:07 +00003127 case UTT_IsTriviallyCopyable:
John McCallf85e1932011-06-15 23:02:42 +00003128 return T.isTriviallyCopyableType(Self.Context);
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003129 case UTT_IsStandardLayout:
3130 return T->isStandardLayoutType();
3131 case UTT_IsPOD:
Benjamin Kramer470360d2012-04-28 10:00:33 +00003132 return T.isPODType(Self.Context);
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003133 case UTT_IsLiteral:
Richard Smitha10b9782013-04-22 15:31:51 +00003134 return T->isLiteralType(Self.Context);
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003135 case UTT_IsEmpty:
3136 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3137 return !RD->isUnion() && RD->isEmpty();
3138 return false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003139 case UTT_IsPolymorphic:
Chandler Carruth28eeb382011-05-01 06:11:03 +00003140 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3141 return RD->isPolymorphic();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003142 return false;
3143 case UTT_IsAbstract:
Chandler Carruth28eeb382011-05-01 06:11:03 +00003144 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3145 return RD->isAbstract();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003146 return false;
John McCallea30e2f2012-09-25 07:32:49 +00003147 case UTT_IsInterfaceClass:
3148 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3149 return RD->isInterface();
3150 return false;
Douglas Gregor5e9392b2011-12-03 18:14:24 +00003151 case UTT_IsFinal:
3152 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3153 return RD->hasAttr<FinalAttr>();
3154 return false;
John Wiegley20c0da72011-04-27 23:09:49 +00003155 case UTT_IsSigned:
3156 return T->isSignedIntegerType();
John Wiegley20c0da72011-04-27 23:09:49 +00003157 case UTT_IsUnsigned:
3158 return T->isUnsignedIntegerType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003159
3160 // Type trait expressions which query classes regarding their construction,
3161 // destruction, and copying. Rather than being based directly on the
3162 // related type predicates in the standard, they are specified by both
3163 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
3164 // specifications.
3165 //
3166 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
3167 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
Richard Smithac713512012-12-08 02:53:02 +00003168 //
3169 // Note that these builtins do not behave as documented in g++: if a class
3170 // has both a trivial and a non-trivial special member of a particular kind,
3171 // they return false! For now, we emulate this behavior.
3172 // FIXME: This appears to be a g++ bug: more complex cases reveal that it
3173 // does not correctly compute triviality in the presence of multiple special
3174 // members of the same kind. Revisit this once the g++ bug is fixed.
Sean Hunt023df372011-05-09 18:22:59 +00003175 case UTT_HasTrivialDefaultConstructor:
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003176 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3177 // If __is_pod (type) is true then the trait is true, else if type is
3178 // a cv class or union type (or array thereof) with a trivial default
3179 // constructor ([class.ctor]) then the trait is true, else it is false.
John McCallf85e1932011-06-15 23:02:42 +00003180 if (T.isPODType(Self.Context))
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003181 return true;
Richard Smithac713512012-12-08 02:53:02 +00003182 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3183 return RD->hasTrivialDefaultConstructor() &&
3184 !RD->hasNonTrivialDefaultConstructor();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003185 return false;
Joao Matos9ef98752013-03-27 01:34:16 +00003186 case UTT_HasTrivialMoveConstructor:
3187 // This trait is implemented by MSVC 2012 and needed to parse the
3188 // standard library headers. Specifically this is used as the logic
3189 // behind std::is_trivially_move_constructible (20.9.4.3).
3190 if (T.isPODType(Self.Context))
3191 return true;
3192 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3193 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
3194 return false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003195 case UTT_HasTrivialCopy:
3196 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3197 // If __is_pod (type) is true or type is a reference type then
3198 // the trait is true, else if type is a cv class or union type
3199 // with a trivial copy constructor ([class.copy]) then the trait
3200 // is true, else it is false.
John McCallf85e1932011-06-15 23:02:42 +00003201 if (T.isPODType(Self.Context) || T->isReferenceType())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003202 return true;
Richard Smithac713512012-12-08 02:53:02 +00003203 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3204 return RD->hasTrivialCopyConstructor() &&
3205 !RD->hasNonTrivialCopyConstructor();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003206 return false;
Joao Matos9ef98752013-03-27 01:34:16 +00003207 case UTT_HasTrivialMoveAssign:
3208 // This trait is implemented by MSVC 2012 and needed to parse the
3209 // standard library headers. Specifically it is used as the logic
3210 // behind std::is_trivially_move_assignable (20.9.4.3)
3211 if (T.isPODType(Self.Context))
3212 return true;
3213 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3214 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
3215 return false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003216 case UTT_HasTrivialAssign:
3217 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3218 // If type is const qualified or is a reference type then the
3219 // trait is false. Otherwise if __is_pod (type) is true then the
3220 // trait is true, else if type is a cv class or union type with
3221 // a trivial copy assignment ([class.copy]) then the trait is
3222 // true, else it is false.
3223 // Note: the const and reference restrictions are interesting,
3224 // given that const and reference members don't prevent a class
3225 // from having a trivial copy assignment operator (but do cause
3226 // errors if the copy assignment operator is actually used, q.v.
3227 // [class.copy]p12).
3228
Richard Smithac713512012-12-08 02:53:02 +00003229 if (T.isConstQualified())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003230 return false;
John McCallf85e1932011-06-15 23:02:42 +00003231 if (T.isPODType(Self.Context))
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003232 return true;
Richard Smithac713512012-12-08 02:53:02 +00003233 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3234 return RD->hasTrivialCopyAssignment() &&
3235 !RD->hasNonTrivialCopyAssignment();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003236 return false;
3237 case UTT_HasTrivialDestructor:
3238 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3239 // If __is_pod (type) is true or type is a reference type
3240 // then the trait is true, else if type is a cv class or union
3241 // type (or array thereof) with a trivial destructor
3242 // ([class.dtor]) then the trait is true, else it is
3243 // false.
John McCallf85e1932011-06-15 23:02:42 +00003244 if (T.isPODType(Self.Context) || T->isReferenceType())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003245 return true;
John McCallf85e1932011-06-15 23:02:42 +00003246
3247 // Objective-C++ ARC: autorelease types don't require destruction.
3248 if (T->isObjCLifetimeType() &&
3249 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
3250 return true;
3251
Richard Smithac713512012-12-08 02:53:02 +00003252 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
3253 return RD->hasTrivialDestructor();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003254 return false;
3255 // TODO: Propagate nothrowness for implicitly declared special members.
3256 case UTT_HasNothrowAssign:
3257 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3258 // If type is const qualified or is a reference type then the
3259 // trait is false. Otherwise if __has_trivial_assign (type)
3260 // is true then the trait is true, else if type is a cv class
3261 // or union type with copy assignment operators that are known
3262 // not to throw an exception then the trait is true, else it is
3263 // false.
3264 if (C.getBaseElementType(T).isConstQualified())
3265 return false;
3266 if (T->isReferenceType())
3267 return false;
John McCallf85e1932011-06-15 23:02:42 +00003268 if (T.isPODType(Self.Context) || T->isObjCLifetimeType())
Joao Matos9ef98752013-03-27 01:34:16 +00003269 return true;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003270
Joao Matos9ef98752013-03-27 01:34:16 +00003271 if (const RecordType *RT = T->getAs<RecordType>())
3272 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3273 &CXXRecordDecl::hasTrivialCopyAssignment,
3274 &CXXRecordDecl::hasNonTrivialCopyAssignment,
3275 &CXXMethodDecl::isCopyAssignmentOperator);
3276 return false;
3277 case UTT_HasNothrowMoveAssign:
3278 // This trait is implemented by MSVC 2012 and needed to parse the
3279 // standard library headers. Specifically this is used as the logic
3280 // behind std::is_nothrow_move_assignable (20.9.4.3).
3281 if (T.isPODType(Self.Context))
3282 return true;
3283
3284 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
3285 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
3286 &CXXRecordDecl::hasTrivialMoveAssignment,
3287 &CXXRecordDecl::hasNonTrivialMoveAssignment,
3288 &CXXMethodDecl::isMoveAssignmentOperator);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003289 return false;
3290 case UTT_HasNothrowCopy:
3291 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3292 // If __has_trivial_copy (type) is true then the trait is true, else
3293 // if type is a cv class or union type with copy constructors that are
3294 // known not to throw an exception then the trait is true, else it is
3295 // false.
John McCallf85e1932011-06-15 23:02:42 +00003296 if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003297 return true;
Richard Smithac713512012-12-08 02:53:02 +00003298 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
3299 if (RD->hasTrivialCopyConstructor() &&
3300 !RD->hasNonTrivialCopyConstructor())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003301 return true;
3302
3303 bool FoundConstructor = false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003304 unsigned FoundTQs;
David Blaikie3bc93e32012-12-19 00:45:41 +00003305 DeclContext::lookup_const_result R = Self.LookupConstructors(RD);
3306 for (DeclContext::lookup_const_iterator Con = R.begin(),
3307 ConEnd = R.end(); Con != ConEnd; ++Con) {
Sebastian Redl08295a52010-09-13 22:18:28 +00003308 // A template constructor is never a copy constructor.
3309 // FIXME: However, it may actually be selected at the actual overload
3310 // resolution point.
3311 if (isa<FunctionTemplateDecl>(*Con))
3312 continue;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003313 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
3314 if (Constructor->isCopyConstructor(FoundTQs)) {
3315 FoundConstructor = true;
3316 const FunctionProtoType *CPT
3317 = Constructor->getType()->getAs<FunctionProtoType>();
Richard Smithe6975e92012-04-17 00:58:00 +00003318 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3319 if (!CPT)
3320 return false;
Sebastian Redl60618fa2011-03-12 11:50:43 +00003321 // FIXME: check whether evaluating default arguments can throw.
Sebastian Redl751025d2010-09-13 22:02:47 +00003322 // For now, we'll be conservative and assume that they can throw.
Richard Smith7a614d82011-06-11 17:19:42 +00003323 if (!CPT->isNothrow(Self.Context) || CPT->getNumArgs() > 1)
3324 return false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003325 }
3326 }
3327
Richard Smith7a614d82011-06-11 17:19:42 +00003328 return FoundConstructor;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003329 }
3330 return false;
3331 case UTT_HasNothrowConstructor:
3332 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3333 // If __has_trivial_constructor (type) is true then the trait is
3334 // true, else if type is a cv class or union type (or array
3335 // thereof) with a default constructor that is known not to
3336 // throw an exception then the trait is true, else it is false.
John McCallf85e1932011-06-15 23:02:42 +00003337 if (T.isPODType(C) || T->isObjCLifetimeType())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003338 return true;
Richard Smithac713512012-12-08 02:53:02 +00003339 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
3340 if (RD->hasTrivialDefaultConstructor() &&
3341 !RD->hasNonTrivialDefaultConstructor())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003342 return true;
3343
David Blaikie3bc93e32012-12-19 00:45:41 +00003344 DeclContext::lookup_const_result R = Self.LookupConstructors(RD);
3345 for (DeclContext::lookup_const_iterator Con = R.begin(),
3346 ConEnd = R.end(); Con != ConEnd; ++Con) {
Sebastian Redl08295a52010-09-13 22:18:28 +00003347 // FIXME: In C++0x, a constructor template can be a default constructor.
3348 if (isa<FunctionTemplateDecl>(*Con))
3349 continue;
Sebastian Redl751025d2010-09-13 22:02:47 +00003350 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
3351 if (Constructor->isDefaultConstructor()) {
3352 const FunctionProtoType *CPT
3353 = Constructor->getType()->getAs<FunctionProtoType>();
Richard Smithe6975e92012-04-17 00:58:00 +00003354 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
3355 if (!CPT)
3356 return false;
Sebastian Redl751025d2010-09-13 22:02:47 +00003357 // TODO: check whether evaluating default arguments can throw.
3358 // For now, we'll be conservative and assume that they can throw.
Sebastian Redl8026f6d2011-03-13 17:09:40 +00003359 return CPT->isNothrow(Self.Context) && CPT->getNumArgs() == 0;
Sebastian Redl751025d2010-09-13 22:02:47 +00003360 }
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003361 }
3362 }
3363 return false;
3364 case UTT_HasVirtualDestructor:
3365 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
3366 // If type is a class type with a virtual destructor ([class.dtor])
3367 // then the trait is true, else it is false.
Richard Smithac713512012-12-08 02:53:02 +00003368 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
Sebastian Redlf8aca862010-09-14 23:40:14 +00003369 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003370 return Destructor->isVirtual();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003371 return false;
Chandler Carruthc41d6b52011-05-01 06:11:07 +00003372
3373 // These type trait expressions are modeled on the specifications for the
3374 // Embarcadero C++0x type trait functions:
3375 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
3376 case UTT_IsCompleteType:
3377 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
3378 // Returns True if and only if T is a complete type at the point of the
3379 // function call.
3380 return !T->isIncompleteType();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003381 }
Chandler Carruth83f563c2011-05-01 07:44:17 +00003382 llvm_unreachable("Type trait not covered by switch");
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003383}
3384
3385ExprResult Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT,
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00003386 SourceLocation KWLoc,
3387 TypeSourceInfo *TSInfo,
3388 SourceLocation RParen) {
3389 QualType T = TSInfo->getType();
Chandler Carrutheb65a102011-04-30 10:07:32 +00003390 if (!CheckUnaryTypeTraitTypeCompleteness(*this, UTT, KWLoc, T))
3391 return ExprError();
Sebastian Redl64b45f72009-01-05 20:52:13 +00003392
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003393 bool Value = false;
3394 if (!T->isDependentType())
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00003395 Value = EvaluateUnaryTypeTrait(*this, UTT, KWLoc, T);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00003396
3397 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, UTT, TSInfo, Value,
Anders Carlsson3292d5c2009-07-07 19:06:02 +00003398 RParen, Context.BoolTy));
Sebastian Redl64b45f72009-01-05 20:52:13 +00003399}
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003400
Francois Pichet6ad6f282010-12-07 00:08:36 +00003401ExprResult Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT,
3402 SourceLocation KWLoc,
3403 ParsedType LhsTy,
3404 ParsedType RhsTy,
3405 SourceLocation RParen) {
3406 TypeSourceInfo *LhsTSInfo;
3407 QualType LhsT = GetTypeFromParser(LhsTy, &LhsTSInfo);
3408 if (!LhsTSInfo)
3409 LhsTSInfo = Context.getTrivialTypeSourceInfo(LhsT);
3410
3411 TypeSourceInfo *RhsTSInfo;
3412 QualType RhsT = GetTypeFromParser(RhsTy, &RhsTSInfo);
3413 if (!RhsTSInfo)
3414 RhsTSInfo = Context.getTrivialTypeSourceInfo(RhsT);
3415
3416 return BuildBinaryTypeTrait(BTT, KWLoc, LhsTSInfo, RhsTSInfo, RParen);
3417}
3418
Douglas Gregor14b23272012-06-29 00:49:17 +00003419/// \brief Determine whether T has a non-trivial Objective-C lifetime in
3420/// ARC mode.
3421static bool hasNontrivialObjCLifetime(QualType T) {
3422 switch (T.getObjCLifetime()) {
3423 case Qualifiers::OCL_ExplicitNone:
3424 return false;
3425
3426 case Qualifiers::OCL_Strong:
3427 case Qualifiers::OCL_Weak:
3428 case Qualifiers::OCL_Autoreleasing:
3429 return true;
3430
3431 case Qualifiers::OCL_None:
3432 return T->isObjCLifetimeType();
3433 }
3434
3435 llvm_unreachable("Unknown ObjC lifetime qualifier");
3436}
3437
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003438static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
3439 ArrayRef<TypeSourceInfo *> Args,
3440 SourceLocation RParenLoc) {
3441 switch (Kind) {
3442 case clang::TT_IsTriviallyConstructible: {
3443 // C++11 [meta.unary.prop]:
Dmitri Gribenko62348f02012-02-24 20:03:35 +00003444 // is_trivially_constructible is defined as:
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003445 //
Dmitri Gribenko62348f02012-02-24 20:03:35 +00003446 // is_constructible<T, Args...>::value is true and the variable
3447 // definition for is_constructible, as defined below, is known to call no
3448 // operation that is not trivial.
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003449 //
3450 // The predicate condition for a template specialization
3451 // is_constructible<T, Args...> shall be satisfied if and only if the
3452 // following variable definition would be well-formed for some invented
3453 // variable t:
3454 //
3455 // T t(create<Args>()...);
3456 if (Args.empty()) {
3457 S.Diag(KWLoc, diag::err_type_trait_arity)
3458 << 1 << 1 << 1 << (int)Args.size();
3459 return false;
3460 }
3461
3462 bool SawVoid = false;
3463 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3464 if (Args[I]->getType()->isVoidType()) {
3465 SawVoid = true;
3466 continue;
3467 }
3468
3469 if (!Args[I]->getType()->isIncompleteType() &&
3470 S.RequireCompleteType(KWLoc, Args[I]->getType(),
3471 diag::err_incomplete_type_used_in_type_trait_expr))
3472 return false;
3473 }
3474
3475 // If any argument was 'void', of course it won't type-check.
3476 if (SawVoid)
3477 return false;
3478
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00003479 SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
3480 SmallVector<Expr *, 2> ArgExprs;
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003481 ArgExprs.reserve(Args.size() - 1);
3482 for (unsigned I = 1, N = Args.size(); I != N; ++I) {
3483 QualType T = Args[I]->getType();
3484 if (T->isObjectType() || T->isFunctionType())
3485 T = S.Context.getRValueReferenceType(T);
3486 OpaqueArgExprs.push_back(
Daniel Dunbar96a00142012-03-09 18:35:03 +00003487 OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003488 T.getNonLValueExprType(S.Context),
3489 Expr::getValueKindForType(T)));
3490 ArgExprs.push_back(&OpaqueArgExprs.back());
3491 }
3492
3493 // Perform the initialization in an unevaluated context within a SFINAE
3494 // trap at translation unit scope.
3495 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
3496 Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
3497 Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl());
3498 InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0]));
3499 InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc,
3500 RParenLoc));
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003501 InitializationSequence Init(S, To, InitKind, ArgExprs);
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003502 if (Init.Failed())
3503 return false;
3504
Benjamin Kramer5354e772012-08-23 23:38:35 +00003505 ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003506 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
3507 return false;
Douglas Gregor14b23272012-06-29 00:49:17 +00003508
3509 // Under Objective-C ARC, if the destination has non-trivial Objective-C
3510 // lifetime, this is a non-trivial construction.
3511 if (S.getLangOpts().ObjCAutoRefCount &&
3512 hasNontrivialObjCLifetime(Args[0]->getType().getNonReferenceType()))
3513 return false;
3514
3515 // The initialization succeeded; now make sure there are no non-trivial
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003516 // calls.
3517 return !Result.get()->hasNonTrivialCall(S.Context);
3518 }
3519 }
3520
3521 return false;
3522}
3523
3524ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
3525 ArrayRef<TypeSourceInfo *> Args,
3526 SourceLocation RParenLoc) {
3527 bool Dependent = false;
3528 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3529 if (Args[I]->getType()->isDependentType()) {
3530 Dependent = true;
3531 break;
3532 }
3533 }
3534
3535 bool Value = false;
3536 if (!Dependent)
3537 Value = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc);
3538
3539 return TypeTraitExpr::Create(Context, Context.BoolTy, KWLoc, Kind,
3540 Args, RParenLoc, Value);
3541}
3542
3543ExprResult Sema::ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
3544 ArrayRef<ParsedType> Args,
3545 SourceLocation RParenLoc) {
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00003546 SmallVector<TypeSourceInfo *, 4> ConvertedArgs;
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00003547 ConvertedArgs.reserve(Args.size());
3548
3549 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3550 TypeSourceInfo *TInfo;
3551 QualType T = GetTypeFromParser(Args[I], &TInfo);
3552 if (!TInfo)
3553 TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc);
3554
3555 ConvertedArgs.push_back(TInfo);
3556 }
3557
3558 return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc);
3559}
3560
Francois Pichet6ad6f282010-12-07 00:08:36 +00003561static bool EvaluateBinaryTypeTrait(Sema &Self, BinaryTypeTrait BTT,
3562 QualType LhsT, QualType RhsT,
3563 SourceLocation KeyLoc) {
Chandler Carruthd064c702011-05-01 08:41:10 +00003564 assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
3565 "Cannot evaluate traits of dependent types");
Francois Pichet6ad6f282010-12-07 00:08:36 +00003566
3567 switch(BTT) {
John McCalld89d30f2011-01-28 22:02:36 +00003568 case BTT_IsBaseOf: {
Francois Pichet6ad6f282010-12-07 00:08:36 +00003569 // C++0x [meta.rel]p2
John McCalld89d30f2011-01-28 22:02:36 +00003570 // Base is a base class of Derived without regard to cv-qualifiers or
Francois Pichet6ad6f282010-12-07 00:08:36 +00003571 // Base and Derived are not unions and name the same class type without
3572 // regard to cv-qualifiers.
Francois Pichet6ad6f282010-12-07 00:08:36 +00003573
John McCalld89d30f2011-01-28 22:02:36 +00003574 const RecordType *lhsRecord = LhsT->getAs<RecordType>();
3575 if (!lhsRecord) return false;
3576
3577 const RecordType *rhsRecord = RhsT->getAs<RecordType>();
3578 if (!rhsRecord) return false;
3579
3580 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
3581 == (lhsRecord == rhsRecord));
3582
3583 if (lhsRecord == rhsRecord)
3584 return !lhsRecord->getDecl()->isUnion();
3585
3586 // C++0x [meta.rel]p2:
3587 // If Base and Derived are class types and are different types
3588 // (ignoring possible cv-qualifiers) then Derived shall be a
3589 // complete type.
3590 if (Self.RequireCompleteType(KeyLoc, RhsT,
3591 diag::err_incomplete_type_used_in_type_trait_expr))
3592 return false;
3593
3594 return cast<CXXRecordDecl>(rhsRecord->getDecl())
3595 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
3596 }
John Wiegley20c0da72011-04-27 23:09:49 +00003597 case BTT_IsSame:
3598 return Self.Context.hasSameType(LhsT, RhsT);
Francois Pichetf1872372010-12-08 22:35:30 +00003599 case BTT_TypeCompatible:
3600 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(),
3601 RhsT.getUnqualifiedType());
John Wiegley20c0da72011-04-27 23:09:49 +00003602 case BTT_IsConvertible:
Douglas Gregor9f361132011-01-27 20:28:01 +00003603 case BTT_IsConvertibleTo: {
3604 // C++0x [meta.rel]p4:
3605 // Given the following function prototype:
3606 //
3607 // template <class T>
3608 // typename add_rvalue_reference<T>::type create();
3609 //
3610 // the predicate condition for a template specialization
3611 // is_convertible<From, To> shall be satisfied if and only if
3612 // the return expression in the following code would be
3613 // well-formed, including any implicit conversions to the return
3614 // type of the function:
3615 //
3616 // To test() {
3617 // return create<From>();
3618 // }
3619 //
3620 // Access checking is performed as if in a context unrelated to To and
3621 // From. Only the validity of the immediate context of the expression
3622 // of the return-statement (including conversions to the return type)
3623 // is considered.
3624 //
3625 // We model the initialization as a copy-initialization of a temporary
3626 // of the appropriate type, which for this expression is identical to the
3627 // return statement (since NRVO doesn't apply).
Eli Friedman2217f852012-08-14 02:06:07 +00003628
3629 // Functions aren't allowed to return function or array types.
3630 if (RhsT->isFunctionType() || RhsT->isArrayType())
3631 return false;
3632
3633 // A return statement in a void function must have void type.
3634 if (RhsT->isVoidType())
3635 return LhsT->isVoidType();
3636
3637 // A function definition requires a complete, non-abstract return type.
3638 if (Self.RequireCompleteType(KeyLoc, RhsT, 0) ||
3639 Self.RequireNonAbstractType(KeyLoc, RhsT, 0))
3640 return false;
3641
3642 // Compute the result of add_rvalue_reference.
Douglas Gregor9f361132011-01-27 20:28:01 +00003643 if (LhsT->isObjectType() || LhsT->isFunctionType())
3644 LhsT = Self.Context.getRValueReferenceType(LhsT);
Eli Friedman2217f852012-08-14 02:06:07 +00003645
3646 // Build a fake source and destination for initialization.
Douglas Gregor9f361132011-01-27 20:28:01 +00003647 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
Douglas Gregorb608b982011-01-28 02:26:04 +00003648 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
Douglas Gregor9f361132011-01-27 20:28:01 +00003649 Expr::getValueKindForType(LhsT));
3650 Expr *FromPtr = &From;
3651 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
3652 SourceLocation()));
3653
Eli Friedman3add9f02012-01-25 01:05:57 +00003654 // Perform the initialization in an unevaluated context within a SFINAE
3655 // trap at translation unit scope.
3656 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
Douglas Gregor1eee5dc2011-01-27 22:31:44 +00003657 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
3658 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003659 InitializationSequence Init(Self, To, Kind, FromPtr);
Sebastian Redl383616c2011-06-05 12:23:28 +00003660 if (Init.Failed())
Douglas Gregor9f361132011-01-27 20:28:01 +00003661 return false;
Douglas Gregor1eee5dc2011-01-27 22:31:44 +00003662
Benjamin Kramer5354e772012-08-23 23:38:35 +00003663 ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
Douglas Gregor9f361132011-01-27 20:28:01 +00003664 return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
3665 }
Douglas Gregor25d0a0f2012-02-23 07:33:15 +00003666
3667 case BTT_IsTriviallyAssignable: {
3668 // C++11 [meta.unary.prop]p3:
3669 // is_trivially_assignable is defined as:
3670 // is_assignable<T, U>::value is true and the assignment, as defined by
3671 // is_assignable, is known to call no operation that is not trivial
3672 //
3673 // is_assignable is defined as:
3674 // The expression declval<T>() = declval<U>() is well-formed when
3675 // treated as an unevaluated operand (Clause 5).
3676 //
3677 // For both, T and U shall be complete types, (possibly cv-qualified)
3678 // void, or arrays of unknown bound.
3679 if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
3680 Self.RequireCompleteType(KeyLoc, LhsT,
3681 diag::err_incomplete_type_used_in_type_trait_expr))
3682 return false;
3683 if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
3684 Self.RequireCompleteType(KeyLoc, RhsT,
3685 diag::err_incomplete_type_used_in_type_trait_expr))
3686 return false;
3687
3688 // cv void is never assignable.
3689 if (LhsT->isVoidType() || RhsT->isVoidType())
3690 return false;
3691
3692 // Build expressions that emulate the effect of declval<T>() and
3693 // declval<U>().
3694 if (LhsT->isObjectType() || LhsT->isFunctionType())
3695 LhsT = Self.Context.getRValueReferenceType(LhsT);
3696 if (RhsT->isObjectType() || RhsT->isFunctionType())
3697 RhsT = Self.Context.getRValueReferenceType(RhsT);
3698 OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
3699 Expr::getValueKindForType(LhsT));
3700 OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context),
3701 Expr::getValueKindForType(RhsT));
3702
3703 // Attempt the assignment in an unevaluated context within a SFINAE
3704 // trap at translation unit scope.
3705 EnterExpressionEvaluationContext Unevaluated(Self, Sema::Unevaluated);
3706 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
3707 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
3708 ExprResult Result = Self.BuildBinOp(/*S=*/0, KeyLoc, BO_Assign, &Lhs, &Rhs);
3709 if (Result.isInvalid() || SFINAE.hasErrorOccurred())
3710 return false;
3711
Douglas Gregor14b23272012-06-29 00:49:17 +00003712 // Under Objective-C ARC, if the destination has non-trivial Objective-C
3713 // lifetime, this is a non-trivial assignment.
3714 if (Self.getLangOpts().ObjCAutoRefCount &&
3715 hasNontrivialObjCLifetime(LhsT.getNonReferenceType()))
3716 return false;
3717
Douglas Gregor25d0a0f2012-02-23 07:33:15 +00003718 return !Result.get()->hasNonTrivialCall(Self.Context);
3719 }
Francois Pichet6ad6f282010-12-07 00:08:36 +00003720 }
3721 llvm_unreachable("Unknown type trait or not implemented");
3722}
3723
3724ExprResult Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT,
3725 SourceLocation KWLoc,
3726 TypeSourceInfo *LhsTSInfo,
3727 TypeSourceInfo *RhsTSInfo,
3728 SourceLocation RParen) {
3729 QualType LhsT = LhsTSInfo->getType();
3730 QualType RhsT = RhsTSInfo->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003731
John McCalld89d30f2011-01-28 22:02:36 +00003732 if (BTT == BTT_TypeCompatible) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003733 if (getLangOpts().CPlusPlus) {
Francois Pichetf1872372010-12-08 22:35:30 +00003734 Diag(KWLoc, diag::err_types_compatible_p_in_cplusplus)
3735 << SourceRange(KWLoc, RParen);
3736 return ExprError();
3737 }
Francois Pichet6ad6f282010-12-07 00:08:36 +00003738 }
3739
3740 bool Value = false;
3741 if (!LhsT->isDependentType() && !RhsT->isDependentType())
3742 Value = EvaluateBinaryTypeTrait(*this, BTT, LhsT, RhsT, KWLoc);
3743
Francois Pichetf1872372010-12-08 22:35:30 +00003744 // Select trait result type.
3745 QualType ResultType;
3746 switch (BTT) {
Francois Pichetf1872372010-12-08 22:35:30 +00003747 case BTT_IsBaseOf: ResultType = Context.BoolTy; break;
John Wiegley20c0da72011-04-27 23:09:49 +00003748 case BTT_IsConvertible: ResultType = Context.BoolTy; break;
3749 case BTT_IsSame: ResultType = Context.BoolTy; break;
Francois Pichetf1872372010-12-08 22:35:30 +00003750 case BTT_TypeCompatible: ResultType = Context.IntTy; break;
Douglas Gregor9f361132011-01-27 20:28:01 +00003751 case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break;
Douglas Gregor25d0a0f2012-02-23 07:33:15 +00003752 case BTT_IsTriviallyAssignable: ResultType = Context.BoolTy;
Francois Pichetf1872372010-12-08 22:35:30 +00003753 }
3754
Francois Pichet6ad6f282010-12-07 00:08:36 +00003755 return Owned(new (Context) BinaryTypeTraitExpr(KWLoc, BTT, LhsTSInfo,
3756 RhsTSInfo, Value, RParen,
Francois Pichetf1872372010-12-08 22:35:30 +00003757 ResultType));
Francois Pichet6ad6f282010-12-07 00:08:36 +00003758}
3759
John Wiegley21ff2e52011-04-28 00:16:57 +00003760ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
3761 SourceLocation KWLoc,
3762 ParsedType Ty,
3763 Expr* DimExpr,
3764 SourceLocation RParen) {
3765 TypeSourceInfo *TSInfo;
3766 QualType T = GetTypeFromParser(Ty, &TSInfo);
3767 if (!TSInfo)
3768 TSInfo = Context.getTrivialTypeSourceInfo(T);
3769
3770 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
3771}
3772
3773static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
3774 QualType T, Expr *DimExpr,
3775 SourceLocation KeyLoc) {
Chandler Carruthd064c702011-05-01 08:41:10 +00003776 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegley21ff2e52011-04-28 00:16:57 +00003777
3778 switch(ATT) {
3779 case ATT_ArrayRank:
3780 if (T->isArrayType()) {
3781 unsigned Dim = 0;
3782 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
3783 ++Dim;
3784 T = AT->getElementType();
3785 }
3786 return Dim;
John Wiegley21ff2e52011-04-28 00:16:57 +00003787 }
John Wiegleycf566412011-04-28 02:06:46 +00003788 return 0;
3789
John Wiegley21ff2e52011-04-28 00:16:57 +00003790 case ATT_ArrayExtent: {
3791 llvm::APSInt Value;
3792 uint64_t Dim;
Richard Smith282e7e62012-02-04 09:53:13 +00003793 if (Self.VerifyIntegerConstantExpression(DimExpr, &Value,
Douglas Gregorab41fe92012-05-04 22:38:52 +00003794 diag::err_dimension_expr_not_constant_integer,
Richard Smith282e7e62012-02-04 09:53:13 +00003795 false).isInvalid())
3796 return 0;
3797 if (Value.isSigned() && Value.isNegative()) {
Daniel Dunbare7d6ca02012-03-09 21:38:22 +00003798 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
3799 << DimExpr->getSourceRange();
Richard Smith282e7e62012-02-04 09:53:13 +00003800 return 0;
John Wiegleycf566412011-04-28 02:06:46 +00003801 }
Richard Smith282e7e62012-02-04 09:53:13 +00003802 Dim = Value.getLimitedValue();
John Wiegley21ff2e52011-04-28 00:16:57 +00003803
3804 if (T->isArrayType()) {
3805 unsigned D = 0;
3806 bool Matched = false;
3807 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
3808 if (Dim == D) {
3809 Matched = true;
3810 break;
3811 }
3812 ++D;
3813 T = AT->getElementType();
3814 }
3815
John Wiegleycf566412011-04-28 02:06:46 +00003816 if (Matched && T->isArrayType()) {
3817 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
3818 return CAT->getSize().getLimitedValue();
3819 }
John Wiegley21ff2e52011-04-28 00:16:57 +00003820 }
John Wiegleycf566412011-04-28 02:06:46 +00003821 return 0;
John Wiegley21ff2e52011-04-28 00:16:57 +00003822 }
3823 }
3824 llvm_unreachable("Unknown type trait or not implemented");
3825}
3826
3827ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT,
3828 SourceLocation KWLoc,
3829 TypeSourceInfo *TSInfo,
3830 Expr* DimExpr,
3831 SourceLocation RParen) {
3832 QualType T = TSInfo->getType();
John Wiegley21ff2e52011-04-28 00:16:57 +00003833
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003834 // FIXME: This should likely be tracked as an APInt to remove any host
3835 // assumptions about the width of size_t on the target.
Chandler Carruthd064c702011-05-01 08:41:10 +00003836 uint64_t Value = 0;
3837 if (!T->isDependentType())
3838 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
3839
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003840 // While the specification for these traits from the Embarcadero C++
3841 // compiler's documentation says the return type is 'unsigned int', Clang
3842 // returns 'size_t'. On Windows, the primary platform for the Embarcadero
3843 // compiler, there is no difference. On several other platforms this is an
3844 // important distinction.
John Wiegley21ff2e52011-04-28 00:16:57 +00003845 return Owned(new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value,
Chandler Carruth06207f62011-05-01 07:49:26 +00003846 DimExpr, RParen,
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003847 Context.getSizeType()));
John Wiegley21ff2e52011-04-28 00:16:57 +00003848}
3849
John Wiegley55262202011-04-25 06:54:41 +00003850ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET,
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003851 SourceLocation KWLoc,
3852 Expr *Queried,
3853 SourceLocation RParen) {
John Wiegley55262202011-04-25 06:54:41 +00003854 // If error parsing the expression, ignore.
3855 if (!Queried)
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003856 return ExprError();
John Wiegley55262202011-04-25 06:54:41 +00003857
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003858 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
John Wiegley55262202011-04-25 06:54:41 +00003859
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00003860 return Result;
John Wiegley55262202011-04-25 06:54:41 +00003861}
3862
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003863static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
3864 switch (ET) {
3865 case ET_IsLValueExpr: return E->isLValue();
3866 case ET_IsRValueExpr: return E->isRValue();
3867 }
3868 llvm_unreachable("Expression trait not covered by switch");
3869}
3870
John Wiegley55262202011-04-25 06:54:41 +00003871ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003872 SourceLocation KWLoc,
3873 Expr *Queried,
3874 SourceLocation RParen) {
John Wiegley55262202011-04-25 06:54:41 +00003875 if (Queried->isTypeDependent()) {
3876 // Delay type-checking for type-dependent expressions.
3877 } else if (Queried->getType()->isPlaceholderType()) {
3878 ExprResult PE = CheckPlaceholderExpr(Queried);
3879 if (PE.isInvalid()) return ExprError();
3880 return BuildExpressionTrait(ET, KWLoc, PE.take(), RParen);
3881 }
3882
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003883 bool Value = EvaluateExpressionTrait(ET, Queried);
Chandler Carruthf7ef0002011-05-01 08:48:19 +00003884
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003885 return Owned(new (Context) ExpressionTraitExpr(KWLoc, ET, Queried, Value,
3886 RParen, Context.BoolTy));
John Wiegley55262202011-04-25 06:54:41 +00003887}
3888
Richard Trieudd225092011-09-15 21:56:47 +00003889QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
John McCallf89e55a2010-11-18 06:31:45 +00003890 ExprValueKind &VK,
3891 SourceLocation Loc,
3892 bool isIndirect) {
Richard Trieudd225092011-09-15 21:56:47 +00003893 assert(!LHS.get()->getType()->isPlaceholderType() &&
3894 !RHS.get()->getType()->isPlaceholderType() &&
John McCallea4aba02011-06-30 17:15:34 +00003895 "placeholders should have been weeded out by now");
3896
3897 // The LHS undergoes lvalue conversions if this is ->*.
3898 if (isIndirect) {
Richard Trieudd225092011-09-15 21:56:47 +00003899 LHS = DefaultLvalueConversion(LHS.take());
3900 if (LHS.isInvalid()) return QualType();
John McCallea4aba02011-06-30 17:15:34 +00003901 }
3902
3903 // The RHS always undergoes lvalue conversions.
Richard Trieudd225092011-09-15 21:56:47 +00003904 RHS = DefaultLvalueConversion(RHS.take());
3905 if (RHS.isInvalid()) return QualType();
John McCallea4aba02011-06-30 17:15:34 +00003906
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003907 const char *OpSpelling = isIndirect ? "->*" : ".*";
3908 // C++ 5.5p2
3909 // The binary operator .* [p3: ->*] binds its second operand, which shall
3910 // be of type "pointer to member of T" (where T is a completely-defined
3911 // class type) [...]
Richard Trieudd225092011-09-15 21:56:47 +00003912 QualType RHSType = RHS.get()->getType();
3913 const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>();
Douglas Gregore7450f52009-03-24 19:52:54 +00003914 if (!MemPtr) {
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003915 Diag(Loc, diag::err_bad_memptr_rhs)
Richard Trieudd225092011-09-15 21:56:47 +00003916 << OpSpelling << RHSType << RHS.get()->getSourceRange();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003917 return QualType();
Mike Stump1eb44332009-09-09 15:08:12 +00003918 }
Douglas Gregore7450f52009-03-24 19:52:54 +00003919
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003920 QualType Class(MemPtr->getClass(), 0);
3921
Douglas Gregor7d520ba2010-10-13 20:41:14 +00003922 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
3923 // member pointer points must be completely-defined. However, there is no
3924 // reason for this semantic distinction, and the rule is not enforced by
3925 // other compilers. Therefore, we do not check this property, as it is
3926 // likely to be considered a defect.
Sebastian Redl59fc2692010-04-10 10:14:54 +00003927
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003928 // C++ 5.5p2
3929 // [...] to its first operand, which shall be of class T or of a class of
3930 // which T is an unambiguous and accessible base class. [p3: a pointer to
3931 // such a class]
Richard Trieudd225092011-09-15 21:56:47 +00003932 QualType LHSType = LHS.get()->getType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003933 if (isIndirect) {
Richard Trieudd225092011-09-15 21:56:47 +00003934 if (const PointerType *Ptr = LHSType->getAs<PointerType>())
3935 LHSType = Ptr->getPointeeType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003936 else {
3937 Diag(Loc, diag::err_bad_memptr_lhs)
Richard Trieudd225092011-09-15 21:56:47 +00003938 << OpSpelling << 1 << LHSType
Douglas Gregor849b2432010-03-31 17:46:05 +00003939 << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003940 return QualType();
3941 }
3942 }
3943
Richard Trieudd225092011-09-15 21:56:47 +00003944 if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
Sebastian Redl17e1d352010-04-23 17:18:26 +00003945 // If we want to check the hierarchy, we need a complete type.
Douglas Gregord10099e2012-05-04 16:32:21 +00003946 if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
3947 OpSpelling, (int)isIndirect)) {
Sebastian Redl17e1d352010-04-23 17:18:26 +00003948 return QualType();
3949 }
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00003950 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
Douglas Gregora8f32e02009-10-06 17:59:45 +00003951 /*DetectVirtual=*/false);
Mike Stump390b4cc2009-05-16 07:39:55 +00003952 // FIXME: Would it be useful to print full ambiguity paths, or is that
3953 // overkill?
Richard Trieudd225092011-09-15 21:56:47 +00003954 if (!IsDerivedFrom(LHSType, Class, Paths) ||
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003955 Paths.isAmbiguous(Context.getCanonicalType(Class))) {
3956 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
Richard Trieudd225092011-09-15 21:56:47 +00003957 << (int)isIndirect << LHS.get()->getType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003958 return QualType();
3959 }
Eli Friedman3005efe2010-01-16 00:00:48 +00003960 // Cast LHS to type of use.
3961 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00003962 ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
Sebastian Redl906082e2010-07-20 04:20:21 +00003963
John McCallf871d0c2010-08-07 06:22:56 +00003964 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00003965 BuildBasePathArray(Paths, BasePath);
Richard Trieudd225092011-09-15 21:56:47 +00003966 LHS = ImpCastExprToType(LHS.take(), UseType, CK_DerivedToBase, VK,
3967 &BasePath);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003968 }
3969
Richard Trieudd225092011-09-15 21:56:47 +00003970 if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) {
Fariborz Jahanian05ebda92009-11-18 21:54:48 +00003971 // Diagnose use of pointer-to-member type which when used as
3972 // the functional cast in a pointer-to-member expression.
3973 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
3974 return QualType();
3975 }
John McCallf89e55a2010-11-18 06:31:45 +00003976
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003977 // C++ 5.5p2
3978 // The result is an object or a function of the type specified by the
3979 // second operand.
3980 // The cv qualifiers are the union of those in the pointer and the left side,
3981 // in accordance with 5.5p5 and 5.2.5.
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003982 QualType Result = MemPtr->getPointeeType();
Richard Trieudd225092011-09-15 21:56:47 +00003983 Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
John McCallf89e55a2010-11-18 06:31:45 +00003984
Douglas Gregor6b4df912011-01-26 16:40:18 +00003985 // C++0x [expr.mptr.oper]p6:
3986 // In a .* expression whose object expression is an rvalue, the program is
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003987 // ill-formed if the second operand is a pointer to member function with
3988 // ref-qualifier &. In a ->* expression or in a .* expression whose object
3989 // expression is an lvalue, the program is ill-formed if the second operand
Douglas Gregor6b4df912011-01-26 16:40:18 +00003990 // is a pointer to member function with ref-qualifier &&.
3991 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
3992 switch (Proto->getRefQualifier()) {
3993 case RQ_None:
3994 // Do nothing
3995 break;
3996
3997 case RQ_LValue:
Richard Trieudd225092011-09-15 21:56:47 +00003998 if (!isIndirect && !LHS.get()->Classify(Context).isLValue())
Douglas Gregor6b4df912011-01-26 16:40:18 +00003999 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
Richard Trieudd225092011-09-15 21:56:47 +00004000 << RHSType << 1 << LHS.get()->getSourceRange();
Douglas Gregor6b4df912011-01-26 16:40:18 +00004001 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004002
Douglas Gregor6b4df912011-01-26 16:40:18 +00004003 case RQ_RValue:
Richard Trieudd225092011-09-15 21:56:47 +00004004 if (isIndirect || !LHS.get()->Classify(Context).isRValue())
Douglas Gregor6b4df912011-01-26 16:40:18 +00004005 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
Richard Trieudd225092011-09-15 21:56:47 +00004006 << RHSType << 0 << LHS.get()->getSourceRange();
Douglas Gregor6b4df912011-01-26 16:40:18 +00004007 break;
4008 }
4009 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004010
John McCallf89e55a2010-11-18 06:31:45 +00004011 // C++ [expr.mptr.oper]p6:
4012 // The result of a .* expression whose second operand is a pointer
4013 // to a data member is of the same value category as its
4014 // first operand. The result of a .* expression whose second
4015 // operand is a pointer to a member function is a prvalue. The
4016 // result of an ->* expression is an lvalue if its second operand
4017 // is a pointer to data member and a prvalue otherwise.
John McCall864c0412011-04-26 20:42:42 +00004018 if (Result->isFunctionType()) {
John McCallf89e55a2010-11-18 06:31:45 +00004019 VK = VK_RValue;
John McCall864c0412011-04-26 20:42:42 +00004020 return Context.BoundMemberTy;
4021 } else if (isIndirect) {
John McCallf89e55a2010-11-18 06:31:45 +00004022 VK = VK_LValue;
John McCall864c0412011-04-26 20:42:42 +00004023 } else {
Richard Trieudd225092011-09-15 21:56:47 +00004024 VK = LHS.get()->getValueKind();
John McCall864c0412011-04-26 20:42:42 +00004025 }
John McCallf89e55a2010-11-18 06:31:45 +00004026
Sebastian Redl7c8bd602009-02-07 20:10:22 +00004027 return Result;
4028}
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004029
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004030/// \brief Try to convert a type to another according to C++0x 5.16p3.
4031///
4032/// This is part of the parameter validation for the ? operator. If either
4033/// value operand is a class type, the two operands are attempted to be
4034/// converted to each other. This function does the conversion in one direction.
Douglas Gregorb70cf442010-03-26 20:14:36 +00004035/// It returns true if the program is ill-formed and has already been diagnosed
4036/// as such.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004037static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
4038 SourceLocation QuestionLoc,
Douglas Gregorb70cf442010-03-26 20:14:36 +00004039 bool &HaveConversion,
4040 QualType &ToType) {
4041 HaveConversion = false;
4042 ToType = To->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004043
4044 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
Douglas Gregorb70cf442010-03-26 20:14:36 +00004045 SourceLocation());
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004046 // C++0x 5.16p3
4047 // The process for determining whether an operand expression E1 of type T1
4048 // can be converted to match an operand expression E2 of type T2 is defined
4049 // as follows:
4050 // -- If E2 is an lvalue:
John McCall7eb0a9e2010-11-24 05:12:34 +00004051 bool ToIsLvalue = To->isLValue();
Douglas Gregor0fd8ff72010-03-26 20:59:55 +00004052 if (ToIsLvalue) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004053 // E1 can be converted to match E2 if E1 can be implicitly converted to
4054 // type "lvalue reference to T2", subject to the constraint that in the
4055 // conversion the reference must bind directly to E1.
Douglas Gregorb70cf442010-03-26 20:14:36 +00004056 QualType T = Self.Context.getLValueReferenceType(ToType);
4057 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004058
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004059 InitializationSequence InitSeq(Self, Entity, Kind, From);
Douglas Gregorb70cf442010-03-26 20:14:36 +00004060 if (InitSeq.isDirectReferenceBinding()) {
4061 ToType = T;
4062 HaveConversion = true;
4063 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004064 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004065
Douglas Gregorb70cf442010-03-26 20:14:36 +00004066 if (InitSeq.isAmbiguous())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004067 return InitSeq.Diagnose(Self, Entity, Kind, From);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004068 }
John McCallb1bdc622010-02-25 01:37:24 +00004069
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004070 // -- If E2 is an rvalue, or if the conversion above cannot be done:
4071 // -- if E1 and E2 have class type, and the underlying class types are
4072 // the same or one is a base class of the other:
4073 QualType FTy = From->getType();
4074 QualType TTy = To->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00004075 const RecordType *FRec = FTy->getAs<RecordType>();
4076 const RecordType *TRec = TTy->getAs<RecordType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004077 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
Douglas Gregorb70cf442010-03-26 20:14:36 +00004078 Self.IsDerivedFrom(FTy, TTy);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004079 if (FRec && TRec &&
Douglas Gregorb70cf442010-03-26 20:14:36 +00004080 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004081 // E1 can be converted to match E2 if the class of T2 is the
4082 // same type as, or a base class of, the class of T1, and
4083 // [cv2 > cv1].
John McCallb1bdc622010-02-25 01:37:24 +00004084 if (FRec == TRec || FDerivedFromT) {
4085 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00004086 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004087 InitializationSequence InitSeq(Self, Entity, Kind, From);
Sebastian Redl383616c2011-06-05 12:23:28 +00004088 if (InitSeq) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00004089 HaveConversion = true;
4090 return false;
4091 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004092
Douglas Gregorb70cf442010-03-26 20:14:36 +00004093 if (InitSeq.isAmbiguous())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004094 return InitSeq.Diagnose(Self, Entity, Kind, From);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004095 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004096 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004097
Douglas Gregorb70cf442010-03-26 20:14:36 +00004098 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004099 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004100
Douglas Gregorb70cf442010-03-26 20:14:36 +00004101 // -- Otherwise: E1 can be converted to match E2 if E1 can be
4102 // implicitly converted to the type that expression E2 would have
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004103 // if E2 were converted to an rvalue (or the type it has, if E2 is
Douglas Gregor0fd8ff72010-03-26 20:59:55 +00004104 // an rvalue).
4105 //
4106 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
4107 // to the array-to-pointer or function-to-pointer conversions.
4108 if (!TTy->getAs<TagType>())
4109 TTy = TTy.getUnqualifiedType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004110
Douglas Gregorb70cf442010-03-26 20:14:36 +00004111 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004112 InitializationSequence InitSeq(Self, Entity, Kind, From);
Sebastian Redl383616c2011-06-05 12:23:28 +00004113 HaveConversion = !InitSeq.Failed();
Douglas Gregorb70cf442010-03-26 20:14:36 +00004114 ToType = TTy;
4115 if (InitSeq.isAmbiguous())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004116 return InitSeq.Diagnose(Self, Entity, Kind, From);
Douglas Gregorb70cf442010-03-26 20:14:36 +00004117
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004118 return false;
4119}
4120
4121/// \brief Try to find a common type for two according to C++0x 5.16p5.
4122///
4123/// This is part of the parameter validation for the ? operator. If either
4124/// value operand is a class type, overload resolution is used to find a
4125/// conversion to a common type.
John Wiegley429bb272011-04-08 18:41:53 +00004126static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
Chandler Carruth82214a82011-02-18 23:54:50 +00004127 SourceLocation QuestionLoc) {
John Wiegley429bb272011-04-08 18:41:53 +00004128 Expr *Args[2] = { LHS.get(), RHS.get() };
Chandler Carruth82214a82011-02-18 23:54:50 +00004129 OverloadCandidateSet CandidateSet(QuestionLoc);
Richard Smith958ba642013-05-05 15:51:06 +00004130 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
Chandler Carruth82214a82011-02-18 23:54:50 +00004131 CandidateSet);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004132
4133 OverloadCandidateSet::iterator Best;
Chandler Carruth82214a82011-02-18 23:54:50 +00004134 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
John Wiegley429bb272011-04-08 18:41:53 +00004135 case OR_Success: {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004136 // We found a match. Perform the conversions on the arguments and move on.
John Wiegley429bb272011-04-08 18:41:53 +00004137 ExprResult LHSRes =
4138 Self.PerformImplicitConversion(LHS.get(), Best->BuiltinTypes.ParamTypes[0],
4139 Best->Conversions[0], Sema::AA_Converting);
4140 if (LHSRes.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004141 break;
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004142 LHS = LHSRes;
John Wiegley429bb272011-04-08 18:41:53 +00004143
4144 ExprResult RHSRes =
4145 Self.PerformImplicitConversion(RHS.get(), Best->BuiltinTypes.ParamTypes[1],
4146 Best->Conversions[1], Sema::AA_Converting);
4147 if (RHSRes.isInvalid())
4148 break;
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004149 RHS = RHSRes;
Chandler Carruth25ca4212011-02-25 19:41:05 +00004150 if (Best->Function)
Eli Friedman5f2987c2012-02-02 03:46:19 +00004151 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004152 return false;
John Wiegley429bb272011-04-08 18:41:53 +00004153 }
4154
Douglas Gregor20093b42009-12-09 23:02:17 +00004155 case OR_No_Viable_Function:
Chandler Carruth82214a82011-02-18 23:54:50 +00004156
4157 // Emit a better diagnostic if one of the expressions is a null pointer
4158 // constant and the other is a pointer type. In this case, the user most
4159 // likely forgot to take the address of the other expression.
John Wiegley429bb272011-04-08 18:41:53 +00004160 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carruth82214a82011-02-18 23:54:50 +00004161 return true;
4162
4163 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley429bb272011-04-08 18:41:53 +00004164 << LHS.get()->getType() << RHS.get()->getType()
4165 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004166 return true;
4167
Douglas Gregor20093b42009-12-09 23:02:17 +00004168 case OR_Ambiguous:
Chandler Carruth82214a82011-02-18 23:54:50 +00004169 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
John Wiegley429bb272011-04-08 18:41:53 +00004170 << LHS.get()->getType() << RHS.get()->getType()
4171 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Mike Stump390b4cc2009-05-16 07:39:55 +00004172 // FIXME: Print the possible common types by printing the return types of
4173 // the viable candidates.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004174 break;
4175
Douglas Gregor20093b42009-12-09 23:02:17 +00004176 case OR_Deleted:
David Blaikieb219cfc2011-09-23 05:06:16 +00004177 llvm_unreachable("Conditional operator has only built-in overloads");
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004178 }
4179 return true;
4180}
4181
Sebastian Redl76458502009-04-17 16:30:52 +00004182/// \brief Perform an "extended" implicit conversion as returned by
4183/// TryClassUnification.
John Wiegley429bb272011-04-08 18:41:53 +00004184static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00004185 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
John Wiegley429bb272011-04-08 18:41:53 +00004186 InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(),
Douglas Gregorb70cf442010-03-26 20:14:36 +00004187 SourceLocation());
John Wiegley429bb272011-04-08 18:41:53 +00004188 Expr *Arg = E.take();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004189 InitializationSequence InitSeq(Self, Entity, Kind, Arg);
Benjamin Kramer5354e772012-08-23 23:38:35 +00004190 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg);
Douglas Gregorb70cf442010-03-26 20:14:36 +00004191 if (Result.isInvalid())
Sebastian Redl76458502009-04-17 16:30:52 +00004192 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004193
John Wiegley429bb272011-04-08 18:41:53 +00004194 E = Result;
Sebastian Redl76458502009-04-17 16:30:52 +00004195 return false;
4196}
4197
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004198/// \brief Check the operands of ?: under C++ semantics.
4199///
4200/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
4201/// extension. In this case, LHS == Cond. (But they're not aliases.)
Richard Smith50d61c82012-08-08 06:13:49 +00004202QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
4203 ExprResult &RHS, ExprValueKind &VK,
4204 ExprObjectKind &OK,
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004205 SourceLocation QuestionLoc) {
Mike Stump390b4cc2009-05-16 07:39:55 +00004206 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
4207 // interface pointers.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004208
Richard Smith604fb382012-08-07 22:06:48 +00004209 // C++11 [expr.cond]p1
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004210 // The first expression is contextually converted to bool.
John Wiegley429bb272011-04-08 18:41:53 +00004211 if (!Cond.get()->isTypeDependent()) {
4212 ExprResult CondRes = CheckCXXBooleanCondition(Cond.take());
4213 if (CondRes.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004214 return QualType();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004215 Cond = CondRes;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004216 }
4217
John McCallf89e55a2010-11-18 06:31:45 +00004218 // Assume r-value.
4219 VK = VK_RValue;
John McCall09431682010-11-18 19:01:18 +00004220 OK = OK_Ordinary;
John McCallf89e55a2010-11-18 06:31:45 +00004221
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004222 // Either of the arguments dependent?
John Wiegley429bb272011-04-08 18:41:53 +00004223 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004224 return Context.DependentTy;
4225
Richard Smith604fb382012-08-07 22:06:48 +00004226 // C++11 [expr.cond]p2
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004227 // If either the second or the third operand has type (cv) void, ...
John Wiegley429bb272011-04-08 18:41:53 +00004228 QualType LTy = LHS.get()->getType();
4229 QualType RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004230 bool LVoid = LTy->isVoidType();
4231 bool RVoid = RTy->isVoidType();
4232 if (LVoid || RVoid) {
4233 // ... then the [l2r] conversions are performed on the second and third
4234 // operands ...
John Wiegley429bb272011-04-08 18:41:53 +00004235 LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
4236 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
4237 if (LHS.isInvalid() || RHS.isInvalid())
4238 return QualType();
Richard Smith604fb382012-08-07 22:06:48 +00004239
4240 // Finish off the lvalue-to-rvalue conversion by copy-initializing a
4241 // temporary if necessary. DefaultFunctionArrayLvalueConversion doesn't
4242 // do this part for us.
4243 ExprResult &NonVoid = LVoid ? RHS : LHS;
4244 if (NonVoid.get()->getType()->isRecordType() &&
4245 NonVoid.get()->isGLValue()) {
David Blaikie654f1d52012-09-10 22:05:41 +00004246 if (RequireNonAbstractType(QuestionLoc, NonVoid.get()->getType(),
4247 diag::err_allocation_of_abstract_type))
4248 return QualType();
Richard Smith604fb382012-08-07 22:06:48 +00004249 InitializedEntity Entity =
4250 InitializedEntity::InitializeTemporary(NonVoid.get()->getType());
4251 NonVoid = PerformCopyInitialization(Entity, SourceLocation(), NonVoid);
4252 if (NonVoid.isInvalid())
4253 return QualType();
4254 }
4255
John Wiegley429bb272011-04-08 18:41:53 +00004256 LTy = LHS.get()->getType();
4257 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004258
4259 // ... and one of the following shall hold:
4260 // -- The second or the third operand (but not both) is a throw-
Richard Smith604fb382012-08-07 22:06:48 +00004261 // expression; the result is of the type of the other and is a prvalue.
John Wiegley429bb272011-04-08 18:41:53 +00004262 bool LThrow = isa<CXXThrowExpr>(LHS.get());
4263 bool RThrow = isa<CXXThrowExpr>(RHS.get());
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004264 if (LThrow && !RThrow)
4265 return RTy;
4266 if (RThrow && !LThrow)
4267 return LTy;
4268
4269 // -- Both the second and third operands have type void; the result is of
Richard Smith604fb382012-08-07 22:06:48 +00004270 // type void and is a prvalue.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004271 if (LVoid && RVoid)
4272 return Context.VoidTy;
4273
4274 // Neither holds, error.
4275 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
4276 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
John Wiegley429bb272011-04-08 18:41:53 +00004277 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004278 return QualType();
4279 }
4280
4281 // Neither is void.
4282
Richard Smith50d61c82012-08-08 06:13:49 +00004283 // C++11 [expr.cond]p3
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004284 // Otherwise, if the second and third operand have different types, and
Richard Smith50d61c82012-08-08 06:13:49 +00004285 // either has (cv) class type [...] an attempt is made to convert each of
4286 // those operands to the type of the other.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004287 if (!Context.hasSameType(LTy, RTy) &&
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004288 (LTy->isRecordType() || RTy->isRecordType())) {
4289 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
4290 // These return true if a single direction is already ambiguous.
Douglas Gregorb70cf442010-03-26 20:14:36 +00004291 QualType L2RType, R2LType;
4292 bool HaveL2R, HaveR2L;
John Wiegley429bb272011-04-08 18:41:53 +00004293 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004294 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00004295 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004296 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004297
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004298 // If both can be converted, [...] the program is ill-formed.
4299 if (HaveL2R && HaveR2L) {
4300 Diag(QuestionLoc, diag::err_conditional_ambiguous)
John Wiegley429bb272011-04-08 18:41:53 +00004301 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004302 return QualType();
4303 }
4304
4305 // If exactly one conversion is possible, that conversion is applied to
4306 // the chosen operand and the converted operands are used in place of the
4307 // original operands for the remainder of this section.
4308 if (HaveL2R) {
John Wiegley429bb272011-04-08 18:41:53 +00004309 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004310 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00004311 LTy = LHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004312 } else if (HaveR2L) {
John Wiegley429bb272011-04-08 18:41:53 +00004313 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004314 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00004315 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004316 }
4317 }
4318
Richard Smith50d61c82012-08-08 06:13:49 +00004319 // C++11 [expr.cond]p3
4320 // if both are glvalues of the same value category and the same type except
4321 // for cv-qualification, an attempt is made to convert each of those
4322 // operands to the type of the other.
4323 ExprValueKind LVK = LHS.get()->getValueKind();
4324 ExprValueKind RVK = RHS.get()->getValueKind();
4325 if (!Context.hasSameType(LTy, RTy) &&
4326 Context.hasSameUnqualifiedType(LTy, RTy) &&
4327 LVK == RVK && LVK != VK_RValue) {
4328 // Since the unqualified types are reference-related and we require the
4329 // result to be as if a reference bound directly, the only conversion
4330 // we can perform is to add cv-qualifiers.
4331 Qualifiers LCVR = Qualifiers::fromCVRMask(LTy.getCVRQualifiers());
4332 Qualifiers RCVR = Qualifiers::fromCVRMask(RTy.getCVRQualifiers());
4333 if (RCVR.isStrictSupersetOf(LCVR)) {
4334 LHS = ImpCastExprToType(LHS.take(), RTy, CK_NoOp, LVK);
4335 LTy = LHS.get()->getType();
4336 }
4337 else if (LCVR.isStrictSupersetOf(RCVR)) {
4338 RHS = ImpCastExprToType(RHS.take(), LTy, CK_NoOp, RVK);
4339 RTy = RHS.get()->getType();
4340 }
4341 }
4342
4343 // C++11 [expr.cond]p4
John McCallf89e55a2010-11-18 06:31:45 +00004344 // If the second and third operands are glvalues of the same value
4345 // category and have the same type, the result is of that type and
4346 // value category and it is a bit-field if the second or the third
4347 // operand is a bit-field, or if both are bit-fields.
John McCall09431682010-11-18 19:01:18 +00004348 // We only extend this to bitfields, not to the crazy other kinds of
4349 // l-values.
Douglas Gregor1927b1f2010-04-01 22:47:07 +00004350 bool Same = Context.hasSameType(LTy, RTy);
Richard Smith50d61c82012-08-08 06:13:49 +00004351 if (Same && LVK == RVK && LVK != VK_RValue &&
John Wiegley429bb272011-04-08 18:41:53 +00004352 LHS.get()->isOrdinaryOrBitFieldObject() &&
4353 RHS.get()->isOrdinaryOrBitFieldObject()) {
4354 VK = LHS.get()->getValueKind();
4355 if (LHS.get()->getObjectKind() == OK_BitField ||
4356 RHS.get()->getObjectKind() == OK_BitField)
John McCall09431682010-11-18 19:01:18 +00004357 OK = OK_BitField;
John McCallf89e55a2010-11-18 06:31:45 +00004358 return LTy;
Fariborz Jahanian3911a1a2010-09-25 01:08:05 +00004359 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004360
Richard Smith50d61c82012-08-08 06:13:49 +00004361 // C++11 [expr.cond]p5
4362 // Otherwise, the result is a prvalue. If the second and third operands
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004363 // do not have the same type, and either has (cv) class type, ...
4364 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
4365 // ... overload resolution is used to determine the conversions (if any)
4366 // to be applied to the operands. If the overload resolution fails, the
4367 // program is ill-formed.
4368 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
4369 return QualType();
4370 }
4371
Richard Smith50d61c82012-08-08 06:13:49 +00004372 // C++11 [expr.cond]p6
4373 // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004374 // conversions are performed on the second and third operands.
John Wiegley429bb272011-04-08 18:41:53 +00004375 LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
4376 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
4377 if (LHS.isInvalid() || RHS.isInvalid())
4378 return QualType();
4379 LTy = LHS.get()->getType();
4380 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004381
4382 // After those conversions, one of the following shall hold:
4383 // -- The second and third operands have the same type; the result
Douglas Gregorb65a4582010-05-19 23:40:50 +00004384 // is of that type. If the operands have class type, the result
4385 // is a prvalue temporary of the result type, which is
4386 // copy-initialized from either the second operand or the third
4387 // operand depending on the value of the first operand.
4388 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
4389 if (LTy->isRecordType()) {
4390 // The operands have class type. Make a temporary copy.
David Blaikie654f1d52012-09-10 22:05:41 +00004391 if (RequireNonAbstractType(QuestionLoc, LTy,
4392 diag::err_allocation_of_abstract_type))
4393 return QualType();
Douglas Gregorb65a4582010-05-19 23:40:50 +00004394 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
David Blaikie654f1d52012-09-10 22:05:41 +00004395
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004396 ExprResult LHSCopy = PerformCopyInitialization(Entity,
4397 SourceLocation(),
John Wiegley429bb272011-04-08 18:41:53 +00004398 LHS);
Douglas Gregorb65a4582010-05-19 23:40:50 +00004399 if (LHSCopy.isInvalid())
4400 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004401
4402 ExprResult RHSCopy = PerformCopyInitialization(Entity,
4403 SourceLocation(),
John Wiegley429bb272011-04-08 18:41:53 +00004404 RHS);
Douglas Gregorb65a4582010-05-19 23:40:50 +00004405 if (RHSCopy.isInvalid())
4406 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004407
John Wiegley429bb272011-04-08 18:41:53 +00004408 LHS = LHSCopy;
4409 RHS = RHSCopy;
Douglas Gregorb65a4582010-05-19 23:40:50 +00004410 }
4411
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004412 return LTy;
Douglas Gregorb65a4582010-05-19 23:40:50 +00004413 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004414
Douglas Gregorfb4a5432010-05-18 22:42:18 +00004415 // Extension: conditional operator involving vector types.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004416 if (LTy->isVectorType() || RTy->isVectorType())
Eli Friedmanb9b4b782011-06-23 18:10:35 +00004417 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false);
Douglas Gregorfb4a5432010-05-18 22:42:18 +00004418
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004419 // -- The second and third operands have arithmetic or enumeration type;
4420 // the usual arithmetic conversions are performed to bring them to a
4421 // common type, and the result is of that type.
4422 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
4423 UsualArithmeticConversions(LHS, RHS);
John Wiegley429bb272011-04-08 18:41:53 +00004424 if (LHS.isInvalid() || RHS.isInvalid())
4425 return QualType();
4426 return LHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004427 }
4428
4429 // -- The second and third operands have pointer type, or one has pointer
Richard Smith50d61c82012-08-08 06:13:49 +00004430 // type and the other is a null pointer constant, or both are null
4431 // pointer constants, at least one of which is non-integral; pointer
4432 // conversions and qualification conversions are performed to bring them
4433 // to their composite pointer type. The result is of the composite
4434 // pointer type.
Eli Friedmande8ac492010-01-02 22:56:07 +00004435 // -- The second and third operands have pointer to member type, or one has
4436 // pointer to member type and the other is a null pointer constant;
4437 // pointer to member conversions and qualification conversions are
4438 // performed to bring them to a common type, whose cv-qualification
4439 // shall match the cv-qualification of either the second or the third
4440 // operand. The result is of the common type.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004441 bool NonStandardCompositeType = false;
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004442 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004443 isSFINAEContext()? 0 : &NonStandardCompositeType);
4444 if (!Composite.isNull()) {
4445 if (NonStandardCompositeType)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004446 Diag(QuestionLoc,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004447 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
4448 << LTy << RTy << Composite
John Wiegley429bb272011-04-08 18:41:53 +00004449 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004450
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004451 return Composite;
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004452 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004453
Douglas Gregor1927b1f2010-04-01 22:47:07 +00004454 // Similarly, attempt to find composite type of two objective-c pointers.
Fariborz Jahanian55016362009-12-10 20:46:08 +00004455 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
4456 if (!Composite.isNull())
4457 return Composite;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004458
Chandler Carruth7ef93242011-02-19 00:13:59 +00004459 // Check if we are using a null with a non-pointer type.
John Wiegley429bb272011-04-08 18:41:53 +00004460 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carruth7ef93242011-02-19 00:13:59 +00004461 return QualType();
4462
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004463 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley429bb272011-04-08 18:41:53 +00004464 << LHS.get()->getType() << RHS.get()->getType()
4465 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00004466 return QualType();
4467}
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004468
4469/// \brief Find a merged pointer type and convert the two expressions to it.
4470///
Douglas Gregor20b3e992009-08-24 17:42:35 +00004471/// This finds the composite pointer type (or member pointer type) for @p E1
Richard Smith50d61c82012-08-08 06:13:49 +00004472/// and @p E2 according to C++11 5.9p2. It converts both expressions to this
Douglas Gregor20b3e992009-08-24 17:42:35 +00004473/// type and returns it.
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004474/// It does not emit diagnostics.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004475///
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004476/// \param Loc The location of the operator requiring these two expressions to
4477/// be converted to the composite pointer type.
4478///
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004479/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
4480/// a non-standard (but still sane) composite type to which both expressions
4481/// can be converted. When such a type is chosen, \c *NonStandardCompositeType
4482/// will be set true.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004483QualType Sema::FindCompositePointerType(SourceLocation Loc,
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004484 Expr *&E1, Expr *&E2,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004485 bool *NonStandardCompositeType) {
4486 if (NonStandardCompositeType)
4487 *NonStandardCompositeType = false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004488
David Blaikie4e4d0842012-03-11 07:00:24 +00004489 assert(getLangOpts().CPlusPlus && "This function assumes C++");
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004490 QualType T1 = E1->getType(), T2 = E2->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00004491
Richard Smith50d61c82012-08-08 06:13:49 +00004492 // C++11 5.9p2
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004493 // Pointer conversions and qualification conversions are performed on
4494 // pointer operands to bring them to their composite pointer type. If
4495 // one operand is a null pointer constant, the composite pointer type is
Richard Smith50d61c82012-08-08 06:13:49 +00004496 // std::nullptr_t if the other operand is also a null pointer constant or,
4497 // if the other operand is a pointer, the type of the other operand.
4498 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
4499 !T2->isAnyPointerType() && !T2->isMemberPointerType()) {
4500 if (T1->isNullPtrType() &&
4501 E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
4502 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take();
4503 return T1;
4504 }
4505 if (T2->isNullPtrType() &&
4506 E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
4507 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take();
4508 return T2;
4509 }
4510 return QualType();
4511 }
4512
Douglas Gregorce940492009-09-25 04:25:58 +00004513 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004514 if (T2->isMemberPointerType())
John Wiegley429bb272011-04-08 18:41:53 +00004515 E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00004516 else
John Wiegley429bb272011-04-08 18:41:53 +00004517 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004518 return T2;
4519 }
Douglas Gregorce940492009-09-25 04:25:58 +00004520 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004521 if (T1->isMemberPointerType())
John Wiegley429bb272011-04-08 18:41:53 +00004522 E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00004523 else
John Wiegley429bb272011-04-08 18:41:53 +00004524 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004525 return T1;
4526 }
Mike Stump1eb44332009-09-09 15:08:12 +00004527
Douglas Gregor20b3e992009-08-24 17:42:35 +00004528 // Now both have to be pointers or member pointers.
Sebastian Redla439e6f2009-11-16 21:03:45 +00004529 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
4530 (!T2->isPointerType() && !T2->isMemberPointerType()))
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004531 return QualType();
4532
4533 // Otherwise, of one of the operands has type "pointer to cv1 void," then
4534 // the other has type "pointer to cv2 T" and the composite pointer type is
4535 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
4536 // Otherwise, the composite pointer type is a pointer type similar to the
4537 // type of one of the operands, with a cv-qualification signature that is
4538 // the union of the cv-qualification signatures of the operand types.
4539 // In practice, the first part here is redundant; it's subsumed by the second.
4540 // What we do here is, we build the two possible composite types, and try the
4541 // conversions in both directions. If only one works, or if the two composite
4542 // types are the same, we have succeeded.
John McCall0953e762009-09-24 19:53:00 +00004543 // FIXME: extended qualifiers?
Chris Lattner5f9e2722011-07-23 10:55:15 +00004544 typedef SmallVector<unsigned, 4> QualifierVector;
Sebastian Redla439e6f2009-11-16 21:03:45 +00004545 QualifierVector QualifierUnion;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004546 typedef SmallVector<std::pair<const Type *, const Type *>, 4>
Sebastian Redla439e6f2009-11-16 21:03:45 +00004547 ContainingClassVector;
4548 ContainingClassVector MemberOfClass;
4549 QualType Composite1 = Context.getCanonicalType(T1),
4550 Composite2 = Context.getCanonicalType(T2);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004551 unsigned NeedConstBefore = 0;
Douglas Gregor20b3e992009-08-24 17:42:35 +00004552 do {
4553 const PointerType *Ptr1, *Ptr2;
4554 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
4555 (Ptr2 = Composite2->getAs<PointerType>())) {
4556 Composite1 = Ptr1->getPointeeType();
4557 Composite2 = Ptr2->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004558
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004559 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004560 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004561 if (NonStandardCompositeType &&
4562 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
4563 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004564
Douglas Gregor20b3e992009-08-24 17:42:35 +00004565 QualifierUnion.push_back(
4566 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
4567 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0));
4568 continue;
4569 }
Mike Stump1eb44332009-09-09 15:08:12 +00004570
Douglas Gregor20b3e992009-08-24 17:42:35 +00004571 const MemberPointerType *MemPtr1, *MemPtr2;
4572 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
4573 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
4574 Composite1 = MemPtr1->getPointeeType();
4575 Composite2 = MemPtr2->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004576
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004577 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004578 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004579 if (NonStandardCompositeType &&
4580 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
4581 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004582
Douglas Gregor20b3e992009-08-24 17:42:35 +00004583 QualifierUnion.push_back(
4584 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
4585 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
4586 MemPtr2->getClass()));
4587 continue;
4588 }
Mike Stump1eb44332009-09-09 15:08:12 +00004589
Douglas Gregor20b3e992009-08-24 17:42:35 +00004590 // FIXME: block pointer types?
Mike Stump1eb44332009-09-09 15:08:12 +00004591
Douglas Gregor20b3e992009-08-24 17:42:35 +00004592 // Cannot unwrap any more types.
4593 break;
4594 } while (true);
Mike Stump1eb44332009-09-09 15:08:12 +00004595
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004596 if (NeedConstBefore && NonStandardCompositeType) {
4597 // Extension: Add 'const' to qualifiers that come before the first qualifier
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004598 // mismatch, so that our (non-standard!) composite type meets the
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00004599 // requirements of C++ [conv.qual]p4 bullet 3.
4600 for (unsigned I = 0; I != NeedConstBefore; ++I) {
4601 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
4602 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
4603 *NonStandardCompositeType = true;
4604 }
4605 }
4606 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004607
Douglas Gregor20b3e992009-08-24 17:42:35 +00004608 // Rewrap the composites as pointers or member pointers with the union CVRs.
Sebastian Redla439e6f2009-11-16 21:03:45 +00004609 ContainingClassVector::reverse_iterator MOC
4610 = MemberOfClass.rbegin();
4611 for (QualifierVector::reverse_iterator
4612 I = QualifierUnion.rbegin(),
4613 E = QualifierUnion.rend();
Douglas Gregor20b3e992009-08-24 17:42:35 +00004614 I != E; (void)++I, ++MOC) {
John McCall0953e762009-09-24 19:53:00 +00004615 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
Douglas Gregor20b3e992009-08-24 17:42:35 +00004616 if (MOC->first && MOC->second) {
4617 // Rebuild member pointer type
John McCall0953e762009-09-24 19:53:00 +00004618 Composite1 = Context.getMemberPointerType(
4619 Context.getQualifiedType(Composite1, Quals),
4620 MOC->first);
4621 Composite2 = Context.getMemberPointerType(
4622 Context.getQualifiedType(Composite2, Quals),
4623 MOC->second);
Douglas Gregor20b3e992009-08-24 17:42:35 +00004624 } else {
4625 // Rebuild pointer type
John McCall0953e762009-09-24 19:53:00 +00004626 Composite1
4627 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
4628 Composite2
4629 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
Douglas Gregor20b3e992009-08-24 17:42:35 +00004630 }
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004631 }
4632
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004633 // Try to convert to the first composite pointer type.
4634 InitializedEntity Entity1
4635 = InitializedEntity::InitializeTemporary(Composite1);
4636 InitializationKind Kind
4637 = InitializationKind::CreateCopy(Loc, SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004638 InitializationSequence E1ToC1(*this, Entity1, Kind, E1);
4639 InitializationSequence E2ToC1(*this, Entity1, Kind, E2);
Mike Stump1eb44332009-09-09 15:08:12 +00004640
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004641 if (E1ToC1 && E2ToC1) {
4642 // Conversion to Composite1 is viable.
4643 if (!Context.hasSameType(Composite1, Composite2)) {
4644 // Composite2 is a different type from Composite1. Check whether
4645 // Composite2 is also viable.
4646 InitializedEntity Entity2
4647 = InitializedEntity::InitializeTemporary(Composite2);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004648 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
4649 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004650 if (E1ToC2 && E2ToC2) {
4651 // Both Composite1 and Composite2 are viable and are different;
4652 // this is an ambiguity.
4653 return QualType();
4654 }
4655 }
4656
4657 // Convert E1 to Composite1
John McCall60d7b3a2010-08-24 06:29:42 +00004658 ExprResult E1Result
Benjamin Kramer5354e772012-08-23 23:38:35 +00004659 = E1ToC1.Perform(*this, Entity1, Kind, E1);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004660 if (E1Result.isInvalid())
4661 return QualType();
4662 E1 = E1Result.takeAs<Expr>();
4663
4664 // Convert E2 to Composite1
John McCall60d7b3a2010-08-24 06:29:42 +00004665 ExprResult E2Result
Benjamin Kramer5354e772012-08-23 23:38:35 +00004666 = E2ToC1.Perform(*this, Entity1, Kind, E2);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004667 if (E2Result.isInvalid())
4668 return QualType();
4669 E2 = E2Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004670
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004671 return Composite1;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004672 }
4673
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004674 // Check whether Composite2 is viable.
4675 InitializedEntity Entity2
4676 = InitializedEntity::InitializeTemporary(Composite2);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004677 InitializationSequence E1ToC2(*this, Entity2, Kind, E1);
4678 InitializationSequence E2ToC2(*this, Entity2, Kind, E2);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004679 if (!E1ToC2 || !E2ToC2)
4680 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004681
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004682 // Convert E1 to Composite2
John McCall60d7b3a2010-08-24 06:29:42 +00004683 ExprResult E1Result
Benjamin Kramer5354e772012-08-23 23:38:35 +00004684 = E1ToC2.Perform(*this, Entity2, Kind, E1);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004685 if (E1Result.isInvalid())
4686 return QualType();
4687 E1 = E1Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004688
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004689 // Convert E2 to Composite2
John McCall60d7b3a2010-08-24 06:29:42 +00004690 ExprResult E2Result
Benjamin Kramer5354e772012-08-23 23:38:35 +00004691 = E2ToC2.Perform(*this, Entity2, Kind, E2);
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004692 if (E2Result.isInvalid())
4693 return QualType();
4694 E2 = E2Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004695
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00004696 return Composite2;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00004697}
Anders Carlsson165a0a02009-05-17 18:41:29 +00004698
John McCall60d7b3a2010-08-24 06:29:42 +00004699ExprResult Sema::MaybeBindToTemporary(Expr *E) {
Douglas Gregor19cc1c72010-11-01 21:10:29 +00004700 if (!E)
4701 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004702
John McCallf85e1932011-06-15 23:02:42 +00004703 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
4704
4705 // If the result is a glvalue, we shouldn't bind it.
4706 if (!E->isRValue())
Anders Carlsson089c2602009-08-15 23:41:35 +00004707 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +00004708
John McCallf85e1932011-06-15 23:02:42 +00004709 // In ARC, calls that return a retainable type can return retained,
4710 // in which case we have to insert a consuming cast.
David Blaikie4e4d0842012-03-11 07:00:24 +00004711 if (getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00004712 E->getType()->isObjCRetainableType()) {
4713
4714 bool ReturnsRetained;
4715
4716 // For actual calls, we compute this by examining the type of the
4717 // called value.
4718 if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
4719 Expr *Callee = Call->getCallee()->IgnoreParens();
4720 QualType T = Callee->getType();
4721
4722 if (T == Context.BoundMemberTy) {
4723 // Handle pointer-to-members.
4724 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee))
4725 T = BinOp->getRHS()->getType();
4726 else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
4727 T = Mem->getMemberDecl()->getType();
4728 }
4729
4730 if (const PointerType *Ptr = T->getAs<PointerType>())
4731 T = Ptr->getPointeeType();
4732 else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>())
4733 T = Ptr->getPointeeType();
4734 else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>())
4735 T = MemPtr->getPointeeType();
4736
4737 const FunctionType *FTy = T->getAs<FunctionType>();
4738 assert(FTy && "call to value not of function type?");
4739 ReturnsRetained = FTy->getExtInfo().getProducesResult();
4740
4741 // ActOnStmtExpr arranges things so that StmtExprs of retainable
4742 // type always produce a +1 object.
4743 } else if (isa<StmtExpr>(E)) {
4744 ReturnsRetained = true;
4745
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004746 // We hit this case with the lambda conversion-to-block optimization;
4747 // we don't want any extra casts here.
4748 } else if (isa<CastExpr>(E) &&
4749 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
4750 return Owned(E);
4751
John McCallf85e1932011-06-15 23:02:42 +00004752 // For message sends and property references, we try to find an
4753 // actual method. FIXME: we should infer retention by selector in
4754 // cases where we don't have an actual method.
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004755 } else {
4756 ObjCMethodDecl *D = 0;
4757 if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) {
4758 D = Send->getMethodDecl();
Patrick Beardeb382ec2012-04-19 00:25:12 +00004759 } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
4760 D = BoxedExpr->getBoxingMethod();
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004761 } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) {
4762 D = ArrayLit->getArrayWithObjectsMethod();
4763 } else if (ObjCDictionaryLiteral *DictLit
4764 = dyn_cast<ObjCDictionaryLiteral>(E)) {
4765 D = DictLit->getDictWithObjectsMethod();
4766 }
John McCallf85e1932011-06-15 23:02:42 +00004767
4768 ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>());
John McCallfc4b1912011-08-03 07:02:44 +00004769
4770 // Don't do reclaims on performSelector calls; despite their
4771 // return type, the invoked method doesn't necessarily actually
4772 // return an object.
4773 if (!ReturnsRetained &&
4774 D && D->getMethodFamily() == OMF_performSelector)
4775 return Owned(E);
John McCallf85e1932011-06-15 23:02:42 +00004776 }
4777
John McCall567c5862011-11-14 19:53:16 +00004778 // Don't reclaim an object of Class type.
4779 if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
4780 return Owned(E);
4781
John McCall7e5e5f42011-07-07 06:58:02 +00004782 ExprNeedsCleanups = true;
4783
John McCall33e56f32011-09-10 06:18:15 +00004784 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
4785 : CK_ARCReclaimReturnedObject);
John McCall7e5e5f42011-07-07 06:58:02 +00004786 return Owned(ImplicitCastExpr::Create(Context, E->getType(), ck, E, 0,
4787 VK_RValue));
John McCallf85e1932011-06-15 23:02:42 +00004788 }
4789
David Blaikie4e4d0842012-03-11 07:00:24 +00004790 if (!getLangOpts().CPlusPlus)
John McCallf85e1932011-06-15 23:02:42 +00004791 return Owned(E);
Douglas Gregor51326552009-12-24 18:51:59 +00004792
Peter Collingbourneb4ab8432012-01-26 03:33:51 +00004793 // Search for the base element type (cf. ASTContext::getBaseElementType) with
4794 // a fast path for the common case that the type is directly a RecordType.
4795 const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
4796 const RecordType *RT = 0;
4797 while (!RT) {
4798 switch (T->getTypeClass()) {
4799 case Type::Record:
4800 RT = cast<RecordType>(T);
4801 break;
4802 case Type::ConstantArray:
4803 case Type::IncompleteArray:
4804 case Type::VariableArray:
4805 case Type::DependentSizedArray:
4806 T = cast<ArrayType>(T)->getElementType().getTypePtr();
4807 break;
4808 default:
4809 return Owned(E);
4810 }
4811 }
Mike Stump1eb44332009-09-09 15:08:12 +00004812
Richard Smith76f3f692012-02-22 02:04:18 +00004813 // That should be enough to guarantee that this type is complete, if we're
4814 // not processing a decltype expression.
Jeffrey Yasskinb7ee2e52011-01-27 19:17:54 +00004815 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Richard Smith213d70b2012-02-18 04:13:32 +00004816 if (RD->isInvalidDecl() || RD->isDependentContext())
John McCall86ff3082010-02-04 22:26:26 +00004817 return Owned(E);
Richard Smith76f3f692012-02-22 02:04:18 +00004818
4819 bool IsDecltype = ExprEvalContexts.back().IsDecltype;
4820 CXXDestructorDecl *Destructor = IsDecltype ? 0 : LookupDestructor(RD);
John McCallf85e1932011-06-15 23:02:42 +00004821
John McCallf85e1932011-06-15 23:02:42 +00004822 if (Destructor) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00004823 MarkFunctionReferenced(E->getExprLoc(), Destructor);
John McCallc91cc662010-04-07 00:41:46 +00004824 CheckDestructorAccess(E->getExprLoc(), Destructor,
4825 PDiag(diag::err_access_dtor_temp)
4826 << E->getType());
Richard Smith82f145d2013-05-04 06:44:46 +00004827 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
4828 return ExprError();
John McCallf85e1932011-06-15 23:02:42 +00004829
Richard Smith76f3f692012-02-22 02:04:18 +00004830 // If destructor is trivial, we can avoid the extra copy.
4831 if (Destructor->isTrivial())
4832 return Owned(E);
Richard Smith213d70b2012-02-18 04:13:32 +00004833
John McCall80ee6e82011-11-10 05:35:25 +00004834 // We need a cleanup, but we don't need to remember the temporary.
John McCallf85e1932011-06-15 23:02:42 +00004835 ExprNeedsCleanups = true;
Richard Smith76f3f692012-02-22 02:04:18 +00004836 }
Richard Smith213d70b2012-02-18 04:13:32 +00004837
4838 CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor);
Richard Smith76f3f692012-02-22 02:04:18 +00004839 CXXBindTemporaryExpr *Bind = CXXBindTemporaryExpr::Create(Context, Temp, E);
4840
4841 if (IsDecltype)
4842 ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind);
4843
4844 return Owned(Bind);
Anders Carlssondef11992009-05-30 20:36:53 +00004845}
4846
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004847ExprResult
John McCall4765fa02010-12-06 08:20:24 +00004848Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) {
Douglas Gregor90f93822009-12-22 22:17:25 +00004849 if (SubExpr.isInvalid())
4850 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004851
John McCall4765fa02010-12-06 08:20:24 +00004852 return Owned(MaybeCreateExprWithCleanups(SubExpr.take()));
Douglas Gregor90f93822009-12-22 22:17:25 +00004853}
4854
John McCall80ee6e82011-11-10 05:35:25 +00004855Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
4856 assert(SubExpr && "sub expression can't be null!");
4857
Eli Friedmand2cce132012-02-02 23:15:15 +00004858 CleanupVarDeclMarking();
4859
John McCall80ee6e82011-11-10 05:35:25 +00004860 unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects;
4861 assert(ExprCleanupObjects.size() >= FirstCleanup);
4862 assert(ExprNeedsCleanups || ExprCleanupObjects.size() == FirstCleanup);
4863 if (!ExprNeedsCleanups)
4864 return SubExpr;
4865
4866 ArrayRef<ExprWithCleanups::CleanupObject> Cleanups
4867 = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
4868 ExprCleanupObjects.size() - FirstCleanup);
4869
4870 Expr *E = ExprWithCleanups::Create(Context, SubExpr, Cleanups);
4871 DiscardCleanupsInEvaluationContext();
4872
4873 return E;
4874}
4875
John McCall4765fa02010-12-06 08:20:24 +00004876Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004877 assert(SubStmt && "sub statement can't be null!");
4878
Eli Friedmand2cce132012-02-02 23:15:15 +00004879 CleanupVarDeclMarking();
4880
John McCallf85e1932011-06-15 23:02:42 +00004881 if (!ExprNeedsCleanups)
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004882 return SubStmt;
4883
4884 // FIXME: In order to attach the temporaries, wrap the statement into
4885 // a StmtExpr; currently this is only used for asm statements.
4886 // This is hacky, either create a new CXXStmtWithTemporaries statement or
4887 // a new AsmStmtWithTemporaries.
Nico Weberd36aa352012-12-29 20:03:39 +00004888 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, SubStmt,
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004889 SourceLocation(),
4890 SourceLocation());
4891 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
4892 SourceLocation());
John McCall4765fa02010-12-06 08:20:24 +00004893 return MaybeCreateExprWithCleanups(E);
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004894}
4895
Richard Smith76f3f692012-02-22 02:04:18 +00004896/// Process the expression contained within a decltype. For such expressions,
4897/// certain semantic checks on temporaries are delayed until this point, and
4898/// are omitted for the 'topmost' call in the decltype expression. If the
4899/// topmost call bound a temporary, strip that temporary off the expression.
4900ExprResult Sema::ActOnDecltypeExpression(Expr *E) {
Benjamin Kramer1b486332012-11-15 15:18:42 +00004901 assert(ExprEvalContexts.back().IsDecltype && "not in a decltype expression");
Richard Smith76f3f692012-02-22 02:04:18 +00004902
4903 // C++11 [expr.call]p11:
4904 // If a function call is a prvalue of object type,
4905 // -- if the function call is either
4906 // -- the operand of a decltype-specifier, or
4907 // -- the right operand of a comma operator that is the operand of a
4908 // decltype-specifier,
4909 // a temporary object is not introduced for the prvalue.
4910
4911 // Recursively rebuild ParenExprs and comma expressions to strip out the
4912 // outermost CXXBindTemporaryExpr, if any.
4913 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
4914 ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr());
4915 if (SubExpr.isInvalid())
4916 return ExprError();
4917 if (SubExpr.get() == PE->getSubExpr())
4918 return Owned(E);
4919 return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.take());
4920 }
4921 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
4922 if (BO->getOpcode() == BO_Comma) {
4923 ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
4924 if (RHS.isInvalid())
4925 return ExprError();
4926 if (RHS.get() == BO->getRHS())
4927 return Owned(E);
4928 return Owned(new (Context) BinaryOperator(BO->getLHS(), RHS.take(),
4929 BO_Comma, BO->getType(),
4930 BO->getValueKind(),
4931 BO->getObjectKind(),
Lang Hamesbe9af122012-10-02 04:45:10 +00004932 BO->getOperatorLoc(),
4933 BO->isFPContractable()));
Richard Smith76f3f692012-02-22 02:04:18 +00004934 }
4935 }
4936
4937 CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
4938 if (TopBind)
4939 E = TopBind->getSubExpr();
4940
4941 // Disable the special decltype handling now.
Benjamin Kramer1b486332012-11-15 15:18:42 +00004942 ExprEvalContexts.back().IsDecltype = false;
Richard Smith76f3f692012-02-22 02:04:18 +00004943
Richard Smithd22f0842012-07-28 19:54:11 +00004944 // In MS mode, don't perform any extra checking of call return types within a
4945 // decltype expression.
4946 if (getLangOpts().MicrosoftMode)
4947 return Owned(E);
4948
Richard Smith76f3f692012-02-22 02:04:18 +00004949 // Perform the semantic checks we delayed until this point.
4950 CallExpr *TopCall = dyn_cast<CallExpr>(E);
Benjamin Kramer1b486332012-11-15 15:18:42 +00004951 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size();
4952 I != N; ++I) {
4953 CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
Richard Smith76f3f692012-02-22 02:04:18 +00004954 if (Call == TopCall)
4955 continue;
4956
4957 if (CheckCallReturnType(Call->getCallReturnType(),
Daniel Dunbar96a00142012-03-09 18:35:03 +00004958 Call->getLocStart(),
Richard Smith76f3f692012-02-22 02:04:18 +00004959 Call, Call->getDirectCallee()))
4960 return ExprError();
4961 }
4962
4963 // Now all relevant types are complete, check the destructors are accessible
4964 // and non-deleted, and annotate them on the temporaries.
Benjamin Kramer1b486332012-11-15 15:18:42 +00004965 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size();
4966 I != N; ++I) {
4967 CXXBindTemporaryExpr *Bind =
4968 ExprEvalContexts.back().DelayedDecltypeBinds[I];
Richard Smith76f3f692012-02-22 02:04:18 +00004969 if (Bind == TopBind)
4970 continue;
4971
4972 CXXTemporary *Temp = Bind->getTemporary();
4973
4974 CXXRecordDecl *RD =
4975 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
4976 CXXDestructorDecl *Destructor = LookupDestructor(RD);
4977 Temp->setDestructor(Destructor);
4978
Richard Smith2f68ca02012-05-11 22:20:10 +00004979 MarkFunctionReferenced(Bind->getExprLoc(), Destructor);
4980 CheckDestructorAccess(Bind->getExprLoc(), Destructor,
Richard Smith76f3f692012-02-22 02:04:18 +00004981 PDiag(diag::err_access_dtor_temp)
Richard Smith2f68ca02012-05-11 22:20:10 +00004982 << Bind->getType());
Richard Smith82f145d2013-05-04 06:44:46 +00004983 if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc()))
4984 return ExprError();
Richard Smith76f3f692012-02-22 02:04:18 +00004985
4986 // We need a cleanup, but we don't need to remember the temporary.
4987 ExprNeedsCleanups = true;
4988 }
4989
4990 // Possibly strip off the top CXXBindTemporaryExpr.
4991 return Owned(E);
4992}
4993
John McCall60d7b3a2010-08-24 06:29:42 +00004994ExprResult
John McCall9ae2f072010-08-23 23:25:46 +00004995Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc,
John McCallb3d87482010-08-24 05:47:05 +00004996 tok::TokenKind OpKind, ParsedType &ObjectType,
Douglas Gregord4dca082010-02-24 18:44:31 +00004997 bool &MayBePseudoDestructor) {
Douglas Gregor2dd078a2009-09-02 22:59:36 +00004998 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCall60d7b3a2010-08-24 06:29:42 +00004999 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
John McCall9ae2f072010-08-23 23:25:46 +00005000 if (Result.isInvalid()) return ExprError();
5001 Base = Result.get();
Mike Stump1eb44332009-09-09 15:08:12 +00005002
John McCall3c3b7f92011-10-25 17:37:35 +00005003 Result = CheckPlaceholderExpr(Base);
5004 if (Result.isInvalid()) return ExprError();
5005 Base = Result.take();
5006
John McCall9ae2f072010-08-23 23:25:46 +00005007 QualType BaseType = Base->getType();
Douglas Gregord4dca082010-02-24 18:44:31 +00005008 MayBePseudoDestructor = false;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005009 if (BaseType->isDependentType()) {
Douglas Gregor43d88632009-11-04 22:49:18 +00005010 // If we have a pointer to a dependent type and are using the -> operator,
5011 // the object type is the type that the pointer points to. We might still
5012 // have enough information about that type to do something useful.
5013 if (OpKind == tok::arrow)
5014 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
5015 BaseType = Ptr->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005016
John McCallb3d87482010-08-24 05:47:05 +00005017 ObjectType = ParsedType::make(BaseType);
Douglas Gregord4dca082010-02-24 18:44:31 +00005018 MayBePseudoDestructor = true;
John McCall9ae2f072010-08-23 23:25:46 +00005019 return Owned(Base);
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005020 }
Mike Stump1eb44332009-09-09 15:08:12 +00005021
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005022 // C++ [over.match.oper]p8:
Mike Stump1eb44332009-09-09 15:08:12 +00005023 // [...] When operator->returns, the operator-> is applied to the value
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005024 // returned, with the original second operand.
5025 if (OpKind == tok::arrow) {
John McCallc4e83212009-09-30 01:01:30 +00005026 // The set of types we've considered so far.
John McCall432887f2009-09-30 01:30:54 +00005027 llvm::SmallPtrSet<CanQualType,8> CTypes;
Chris Lattner5f9e2722011-07-23 10:55:15 +00005028 SmallVector<SourceLocation, 8> Locations;
John McCall432887f2009-09-30 01:30:54 +00005029 CTypes.insert(Context.getCanonicalType(BaseType));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005030
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005031 while (BaseType->isRecordType()) {
John McCall9ae2f072010-08-23 23:25:46 +00005032 Result = BuildOverloadedArrowExpr(S, Base, OpLoc);
5033 if (Result.isInvalid())
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005034 return ExprError();
John McCall9ae2f072010-08-23 23:25:46 +00005035 Base = Result.get();
5036 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
Anders Carlssonde699e52009-10-13 22:55:59 +00005037 Locations.push_back(OpCall->getDirectCallee()->getLocation());
John McCall9ae2f072010-08-23 23:25:46 +00005038 BaseType = Base->getType();
John McCallc4e83212009-09-30 01:01:30 +00005039 CanQualType CBaseType = Context.getCanonicalType(BaseType);
John McCall432887f2009-09-30 01:30:54 +00005040 if (!CTypes.insert(CBaseType)) {
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00005041 Diag(OpLoc, diag::err_operator_arrow_circular);
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00005042 for (unsigned i = 0; i < Locations.size(); i++)
5043 Diag(Locations[i], diag::note_declared_at);
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00005044 return ExprError();
5045 }
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005046 }
Mike Stump1eb44332009-09-09 15:08:12 +00005047
Douglas Gregor1d7049a2012-01-12 16:11:24 +00005048 if (BaseType->isPointerType() || BaseType->isObjCObjectPointerType())
Douglas Gregor31658df2009-11-20 19:58:21 +00005049 BaseType = BaseType->getPointeeType();
5050 }
Mike Stump1eb44332009-09-09 15:08:12 +00005051
Douglas Gregor1d7049a2012-01-12 16:11:24 +00005052 // Objective-C properties allow "." access on Objective-C pointer types,
5053 // so adjust the base type to the object type itself.
5054 if (BaseType->isObjCObjectPointerType())
5055 BaseType = BaseType->getPointeeType();
5056
5057 // C++ [basic.lookup.classref]p2:
5058 // [...] If the type of the object expression is of pointer to scalar
5059 // type, the unqualified-id is looked up in the context of the complete
5060 // postfix-expression.
5061 //
5062 // This also indicates that we could be parsing a pseudo-destructor-name.
5063 // Note that Objective-C class and object types can be pseudo-destructor
5064 // expressions or normal member (ivar or property) access expressions.
5065 if (BaseType->isObjCObjectOrInterfaceType()) {
5066 MayBePseudoDestructor = true;
5067 } else if (!BaseType->isRecordType()) {
John McCallb3d87482010-08-24 05:47:05 +00005068 ObjectType = ParsedType();
Douglas Gregord4dca082010-02-24 18:44:31 +00005069 MayBePseudoDestructor = true;
John McCall9ae2f072010-08-23 23:25:46 +00005070 return Owned(Base);
Douglas Gregorc68afe22009-09-03 21:38:09 +00005071 }
Mike Stump1eb44332009-09-09 15:08:12 +00005072
Douglas Gregorcefc3af2012-04-16 07:05:22 +00005073 // The object type must be complete (or dependent), or
5074 // C++11 [expr.prim.general]p3:
5075 // Unlike the object expression in other contexts, *this is not required to
5076 // be of complete type for purposes of class member access (5.2.5) outside
5077 // the member function body.
Douglas Gregor03c57052009-11-17 05:17:33 +00005078 if (!BaseType->isDependentType() &&
Douglas Gregorcefc3af2012-04-16 07:05:22 +00005079 !isThisOutsideMemberFunctionBody(BaseType) &&
Douglas Gregord10099e2012-05-04 16:32:21 +00005080 RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
Douglas Gregor03c57052009-11-17 05:17:33 +00005081 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005082
Douglas Gregorc68afe22009-09-03 21:38:09 +00005083 // C++ [basic.lookup.classref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00005084 // If the id-expression in a class member access (5.2.5) is an
Douglas Gregor03c57052009-11-17 05:17:33 +00005085 // unqualified-id, and the type of the object expression is of a class
Douglas Gregorc68afe22009-09-03 21:38:09 +00005086 // type C (or of pointer to a class type C), the unqualified-id is looked
5087 // up in the scope of class C. [...]
John McCallb3d87482010-08-24 05:47:05 +00005088 ObjectType = ParsedType::make(BaseType);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005089 return Base;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00005090}
5091
John McCall60d7b3a2010-08-24 06:29:42 +00005092ExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc,
John McCall9ae2f072010-08-23 23:25:46 +00005093 Expr *MemExpr) {
Douglas Gregor77549082010-02-24 21:29:12 +00005094 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc);
John McCall9ae2f072010-08-23 23:25:46 +00005095 Diag(MemExpr->getLocStart(), diag::err_dtor_expr_without_call)
5096 << isa<CXXPseudoDestructorExpr>(MemExpr)
Douglas Gregor849b2432010-03-31 17:46:05 +00005097 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005098
Douglas Gregor77549082010-02-24 21:29:12 +00005099 return ActOnCallExpr(/*Scope*/ 0,
John McCall9ae2f072010-08-23 23:25:46 +00005100 MemExpr,
Douglas Gregor77549082010-02-24 21:29:12 +00005101 /*LPLoc*/ ExpectedLParenLoc,
John McCallf312b1e2010-08-26 23:41:50 +00005102 MultiExprArg(),
Douglas Gregor77549082010-02-24 21:29:12 +00005103 /*RPLoc*/ ExpectedLParenLoc);
5104}
Douglas Gregord4dca082010-02-24 18:44:31 +00005105
Eli Friedmane0dbedf2012-01-25 04:29:24 +00005106static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
David Blaikie91ec7892011-12-16 16:03:09 +00005107 tok::TokenKind& OpKind, SourceLocation OpLoc) {
Eli Friedmane0dbedf2012-01-25 04:29:24 +00005108 if (Base->hasPlaceholderType()) {
5109 ExprResult result = S.CheckPlaceholderExpr(Base);
5110 if (result.isInvalid()) return true;
5111 Base = result.take();
5112 }
5113 ObjectType = Base->getType();
5114
David Blaikie91ec7892011-12-16 16:03:09 +00005115 // C++ [expr.pseudo]p2:
5116 // The left-hand side of the dot operator shall be of scalar type. The
5117 // left-hand side of the arrow operator shall be of pointer to scalar type.
5118 // This scalar type is the object type.
Eli Friedmane0dbedf2012-01-25 04:29:24 +00005119 // Note that this is rather different from the normal handling for the
5120 // arrow operator.
David Blaikie91ec7892011-12-16 16:03:09 +00005121 if (OpKind == tok::arrow) {
5122 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
5123 ObjectType = Ptr->getPointeeType();
5124 } else if (!Base->isTypeDependent()) {
5125 // The user wrote "p->" when she probably meant "p."; fix it.
5126 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
5127 << ObjectType << true
5128 << FixItHint::CreateReplacement(OpLoc, ".");
5129 if (S.isSFINAEContext())
5130 return true;
5131
5132 OpKind = tok::period;
5133 }
5134 }
5135
5136 return false;
5137}
5138
John McCall60d7b3a2010-08-24 06:29:42 +00005139ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base,
John McCall2d9f5fa2011-02-25 05:21:17 +00005140 SourceLocation OpLoc,
5141 tok::TokenKind OpKind,
5142 const CXXScopeSpec &SS,
5143 TypeSourceInfo *ScopeTypeInfo,
5144 SourceLocation CCLoc,
5145 SourceLocation TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005146 PseudoDestructorTypeStorage Destructed,
John McCall2d9f5fa2011-02-25 05:21:17 +00005147 bool HasTrailingLParen) {
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005148 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005149
Eli Friedman8c9fe202012-01-25 04:35:06 +00005150 QualType ObjectType;
David Blaikie91ec7892011-12-16 16:03:09 +00005151 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5152 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005153
Douglas Gregor0cb89392012-09-10 14:57:06 +00005154 if (!ObjectType->isDependentType() && !ObjectType->isScalarType() &&
5155 !ObjectType->isVectorType()) {
David Blaikie4e4d0842012-03-11 07:00:24 +00005156 if (getLangOpts().MicrosoftMode && ObjectType->isVoidType())
Nico Weber2d757ec2012-01-23 06:08:16 +00005157 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange();
Nico Weberdf1be862012-01-23 05:50:57 +00005158 else
5159 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
5160 << ObjectType << Base->getSourceRange();
Douglas Gregorb57fb492010-02-24 22:38:50 +00005161 return ExprError();
5162 }
5163
5164 // C++ [expr.pseudo]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005165 // [...] The cv-unqualified versions of the object type and of the type
Douglas Gregorb57fb492010-02-24 22:38:50 +00005166 // designated by the pseudo-destructor-name shall be the same type.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005167 if (DestructedTypeInfo) {
5168 QualType DestructedType = DestructedTypeInfo->getType();
5169 SourceLocation DestructedTypeStart
Abramo Bagnarabd054db2010-05-20 10:00:11 +00005170 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
John McCallf85e1932011-06-15 23:02:42 +00005171 if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {
5172 if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
5173 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
5174 << ObjectType << DestructedType << Base->getSourceRange()
5175 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005176
John McCallf85e1932011-06-15 23:02:42 +00005177 // Recover by setting the destructed type to the object type.
5178 DestructedType = ObjectType;
5179 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005180 DestructedTypeStart);
John McCallf85e1932011-06-15 23:02:42 +00005181 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5182 } else if (DestructedType.getObjCLifetime() !=
5183 ObjectType.getObjCLifetime()) {
5184
5185 if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {
5186 // Okay: just pretend that the user provided the correctly-qualified
5187 // type.
5188 } else {
5189 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
5190 << ObjectType << DestructedType << Base->getSourceRange()
5191 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
5192 }
5193
5194 // Recover by setting the destructed type to the object type.
5195 DestructedType = ObjectType;
5196 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
5197 DestructedTypeStart);
5198 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5199 }
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005200 }
Douglas Gregorb57fb492010-02-24 22:38:50 +00005201 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005202
Douglas Gregorb57fb492010-02-24 22:38:50 +00005203 // C++ [expr.pseudo]p2:
5204 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
5205 // form
5206 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005207 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
Douglas Gregorb57fb492010-02-24 22:38:50 +00005208 //
5209 // shall designate the same scalar type.
5210 if (ScopeTypeInfo) {
5211 QualType ScopeType = ScopeTypeInfo->getType();
5212 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
John McCall81e317a2010-06-11 17:36:40 +00005213 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005214
Abramo Bagnarabd054db2010-05-20 10:00:11 +00005215 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
Douglas Gregorb57fb492010-02-24 22:38:50 +00005216 diag::err_pseudo_dtor_type_mismatch)
John McCall9ae2f072010-08-23 23:25:46 +00005217 << ObjectType << ScopeType << Base->getSourceRange()
Abramo Bagnarabd054db2010-05-20 10:00:11 +00005218 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005219
Douglas Gregorb57fb492010-02-24 22:38:50 +00005220 ScopeType = QualType();
5221 ScopeTypeInfo = 0;
5222 }
5223 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005224
John McCall9ae2f072010-08-23 23:25:46 +00005225 Expr *Result
5226 = new (Context) CXXPseudoDestructorExpr(Context, Base,
5227 OpKind == tok::arrow, OpLoc,
Douglas Gregorf3db29f2011-02-25 18:19:59 +00005228 SS.getWithLocInContext(Context),
John McCall9ae2f072010-08-23 23:25:46 +00005229 ScopeTypeInfo,
5230 CCLoc,
5231 TildeLoc,
5232 Destructed);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005233
Douglas Gregorb57fb492010-02-24 22:38:50 +00005234 if (HasTrailingLParen)
John McCall9ae2f072010-08-23 23:25:46 +00005235 return Owned(Result);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005236
John McCall9ae2f072010-08-23 23:25:46 +00005237 return DiagnoseDtorReference(Destructed.getLocation(), Result);
Douglas Gregor77549082010-02-24 21:29:12 +00005238}
5239
John McCall60d7b3a2010-08-24 06:29:42 +00005240ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
John McCall2d9f5fa2011-02-25 05:21:17 +00005241 SourceLocation OpLoc,
5242 tok::TokenKind OpKind,
5243 CXXScopeSpec &SS,
5244 UnqualifiedId &FirstTypeName,
5245 SourceLocation CCLoc,
5246 SourceLocation TildeLoc,
5247 UnqualifiedId &SecondTypeName,
5248 bool HasTrailingLParen) {
Douglas Gregor77549082010-02-24 21:29:12 +00005249 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5250 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5251 "Invalid first type name in pseudo-destructor");
5252 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
5253 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
5254 "Invalid second type name in pseudo-destructor");
5255
Eli Friedman8c9fe202012-01-25 04:35:06 +00005256 QualType ObjectType;
David Blaikie91ec7892011-12-16 16:03:09 +00005257 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5258 return ExprError();
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005259
5260 // Compute the object type that we should use for name lookup purposes. Only
5261 // record types and dependent types matter.
John McCallb3d87482010-08-24 05:47:05 +00005262 ParsedType ObjectTypePtrForLookup;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005263 if (!SS.isSet()) {
John McCall2d9f5fa2011-02-25 05:21:17 +00005264 if (ObjectType->isRecordType())
5265 ObjectTypePtrForLookup = ParsedType::make(ObjectType);
John McCallb3d87482010-08-24 05:47:05 +00005266 else if (ObjectType->isDependentType())
5267 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005268 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005269
5270 // Convert the name of the type being destructed (following the ~) into a
Douglas Gregorb57fb492010-02-24 22:38:50 +00005271 // type (with source-location information).
Douglas Gregor77549082010-02-24 21:29:12 +00005272 QualType DestructedType;
5273 TypeSourceInfo *DestructedTypeInfo = 0;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005274 PseudoDestructorTypeStorage Destructed;
Douglas Gregor77549082010-02-24 21:29:12 +00005275 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005276 ParsedType T = getTypeName(*SecondTypeName.Identifier,
John McCallb3d87482010-08-24 05:47:05 +00005277 SecondTypeName.StartLocation,
Fariborz Jahanian1e52dfc2011-02-08 18:05:59 +00005278 S, &SS, true, false, ObjectTypePtrForLookup);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005279 if (!T &&
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005280 ((SS.isSet() && !computeDeclContext(SS, false)) ||
5281 (!SS.isSet() && ObjectType->isDependentType()))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005282 // The name of the type being destroyed is a dependent name, and we
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005283 // couldn't find anything useful in scope. Just store the identifier and
5284 // it's location, and we'll perform (qualified) name lookup again at
5285 // template instantiation time.
5286 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
5287 SecondTypeName.StartLocation);
5288 } else if (!T) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005289 Diag(SecondTypeName.StartLocation,
Douglas Gregor77549082010-02-24 21:29:12 +00005290 diag::err_pseudo_dtor_destructor_non_type)
5291 << SecondTypeName.Identifier << ObjectType;
5292 if (isSFINAEContext())
5293 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005294
Douglas Gregor77549082010-02-24 21:29:12 +00005295 // Recover by assuming we had the right type all along.
5296 DestructedType = ObjectType;
Douglas Gregorb57fb492010-02-24 22:38:50 +00005297 } else
Douglas Gregor77549082010-02-24 21:29:12 +00005298 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00005299 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00005300 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00005301 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
Benjamin Kramer5354e772012-08-23 23:38:35 +00005302 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregorb57fb492010-02-24 22:38:50 +00005303 TemplateId->NumArgs);
Douglas Gregor059101f2011-03-02 00:47:37 +00005304 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
Abramo Bagnara55d23c92012-02-06 14:41:24 +00005305 TemplateId->TemplateKWLoc,
Douglas Gregor059101f2011-03-02 00:47:37 +00005306 TemplateId->Template,
Douglas Gregorb57fb492010-02-24 22:38:50 +00005307 TemplateId->TemplateNameLoc,
5308 TemplateId->LAngleLoc,
5309 TemplateArgsPtr,
5310 TemplateId->RAngleLoc);
5311 if (T.isInvalid() || !T.get()) {
5312 // Recover by assuming we had the right type all along.
5313 DestructedType = ObjectType;
5314 } else
5315 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00005316 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005317
5318 // If we've performed some kind of recovery, (re-)build the type source
Douglas Gregorb57fb492010-02-24 22:38:50 +00005319 // information.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005320 if (!DestructedType.isNull()) {
5321 if (!DestructedTypeInfo)
5322 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
Douglas Gregorb57fb492010-02-24 22:38:50 +00005323 SecondTypeName.StartLocation);
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005324 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
5325 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005326
Douglas Gregorb57fb492010-02-24 22:38:50 +00005327 // Convert the name of the scope type (the type prior to '::') into a type.
5328 TypeSourceInfo *ScopeTypeInfo = 0;
Douglas Gregor77549082010-02-24 21:29:12 +00005329 QualType ScopeType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005330 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
Douglas Gregor77549082010-02-24 21:29:12 +00005331 FirstTypeName.Identifier) {
5332 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005333 ParsedType T = getTypeName(*FirstTypeName.Identifier,
John McCallb3d87482010-08-24 05:47:05 +00005334 FirstTypeName.StartLocation,
Douglas Gregorf3db29f2011-02-25 18:19:59 +00005335 S, &SS, true, false, ObjectTypePtrForLookup);
Douglas Gregor77549082010-02-24 21:29:12 +00005336 if (!T) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005337 Diag(FirstTypeName.StartLocation,
Douglas Gregor77549082010-02-24 21:29:12 +00005338 diag::err_pseudo_dtor_destructor_non_type)
5339 << FirstTypeName.Identifier << ObjectType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005340
Douglas Gregorb57fb492010-02-24 22:38:50 +00005341 if (isSFINAEContext())
5342 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005343
Douglas Gregorb57fb492010-02-24 22:38:50 +00005344 // Just drop this type. It's unnecessary anyway.
5345 ScopeType = QualType();
5346 } else
5347 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00005348 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00005349 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00005350 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
Benjamin Kramer5354e772012-08-23 23:38:35 +00005351 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
Douglas Gregorb57fb492010-02-24 22:38:50 +00005352 TemplateId->NumArgs);
Douglas Gregor059101f2011-03-02 00:47:37 +00005353 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
Abramo Bagnara55d23c92012-02-06 14:41:24 +00005354 TemplateId->TemplateKWLoc,
Douglas Gregor059101f2011-03-02 00:47:37 +00005355 TemplateId->Template,
Douglas Gregorb57fb492010-02-24 22:38:50 +00005356 TemplateId->TemplateNameLoc,
5357 TemplateId->LAngleLoc,
5358 TemplateArgsPtr,
5359 TemplateId->RAngleLoc);
5360 if (T.isInvalid() || !T.get()) {
5361 // Recover by dropping this type.
5362 ScopeType = QualType();
5363 } else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005364 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00005365 }
5366 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005367
Douglas Gregorb4a418f2010-02-24 23:02:30 +00005368 if (!ScopeType.isNull() && !ScopeTypeInfo)
5369 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
5370 FirstTypeName.StartLocation);
5371
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005372
John McCall9ae2f072010-08-23 23:25:46 +00005373 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
Douglas Gregorfce46ee2010-02-24 23:50:37 +00005374 ScopeTypeInfo, CCLoc, TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00005375 Destructed, HasTrailingLParen);
Douglas Gregord4dca082010-02-24 18:44:31 +00005376}
5377
David Blaikie91ec7892011-12-16 16:03:09 +00005378ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5379 SourceLocation OpLoc,
5380 tok::TokenKind OpKind,
5381 SourceLocation TildeLoc,
5382 const DeclSpec& DS,
5383 bool HasTrailingLParen) {
Eli Friedman8c9fe202012-01-25 04:35:06 +00005384 QualType ObjectType;
David Blaikie91ec7892011-12-16 16:03:09 +00005385 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
5386 return ExprError();
5387
5388 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
5389
5390 TypeLocBuilder TLB;
5391 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
5392 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
5393 TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
5394 PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
5395
5396 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),
5397 0, SourceLocation(), TildeLoc,
5398 Destructed, HasTrailingLParen);
5399}
5400
John Wiegley429bb272011-04-08 18:41:53 +00005401ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
Eli Friedman3f01c8a2012-03-01 01:30:04 +00005402 CXXConversionDecl *Method,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005403 bool HadMultipleCandidates) {
Eli Friedman23f02672012-03-01 04:01:32 +00005404 if (Method->getParent()->isLambda() &&
5405 Method->getConversionType()->isBlockPointerType()) {
5406 // This is a lambda coversion to block pointer; check if the argument
5407 // is a LambdaExpr.
5408 Expr *SubE = E;
5409 CastExpr *CE = dyn_cast<CastExpr>(SubE);
5410 if (CE && CE->getCastKind() == CK_NoOp)
5411 SubE = CE->getSubExpr();
5412 SubE = SubE->IgnoreParens();
5413 if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
5414 SubE = BE->getSubExpr();
5415 if (isa<LambdaExpr>(SubE)) {
5416 // For the conversion to block pointer on a lambda expression, we
5417 // construct a special BlockLiteral instead; this doesn't really make
5418 // a difference in ARC, but outside of ARC the resulting block literal
5419 // follows the normal lifetime rules for block literals instead of being
5420 // autoreleased.
5421 DiagnosticErrorTrap Trap(Diags);
5422 ExprResult Exp = BuildBlockForLambdaConversion(E->getExprLoc(),
5423 E->getExprLoc(),
5424 Method, E);
5425 if (Exp.isInvalid())
5426 Diag(E->getExprLoc(), diag::note_lambda_to_block_conv);
5427 return Exp;
5428 }
5429 }
5430
5431
John Wiegley429bb272011-04-08 18:41:53 +00005432 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/0,
5433 FoundDecl, Method);
5434 if (Exp.isInvalid())
Douglas Gregorf2ae5262011-01-20 00:18:04 +00005435 return true;
Eli Friedman772fffa2009-12-09 04:53:56 +00005436
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005437 MemberExpr *ME =
John Wiegley429bb272011-04-08 18:41:53 +00005438 new (Context) MemberExpr(Exp.take(), /*IsArrow=*/false, Method,
Abramo Bagnara960809e2011-11-16 22:46:05 +00005439 SourceLocation(), Context.BoundMemberTy,
John McCallf89e55a2010-11-18 06:31:45 +00005440 VK_RValue, OK_Ordinary);
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005441 if (HadMultipleCandidates)
5442 ME->setHadMultipleCandidates(true);
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00005443 MarkMemberReferenced(ME);
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005444
John McCallf89e55a2010-11-18 06:31:45 +00005445 QualType ResultType = Method->getResultType();
5446 ExprValueKind VK = Expr::getValueKindForType(ResultType);
5447 ResultType = ResultType.getNonLValueExprType(Context);
5448
Douglas Gregor7edfb692009-11-23 12:27:39 +00005449 CXXMemberCallExpr *CE =
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00005450 new (Context) CXXMemberCallExpr(Context, ME, MultiExprArg(), ResultType, VK,
John Wiegley429bb272011-04-08 18:41:53 +00005451 Exp.get()->getLocEnd());
Fariborz Jahanianb7400232009-09-28 23:23:40 +00005452 return CE;
5453}
5454
Sebastian Redl2e156222010-09-10 20:55:43 +00005455ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
5456 SourceLocation RParen) {
Richard Smithe6975e92012-04-17 00:58:00 +00005457 CanThrowResult CanThrow = canThrow(Operand);
Sebastian Redl2e156222010-09-10 20:55:43 +00005458 return Owned(new (Context) CXXNoexceptExpr(Context.BoolTy, Operand,
Richard Smithe6975e92012-04-17 00:58:00 +00005459 CanThrow, KeyLoc, RParen));
Sebastian Redl2e156222010-09-10 20:55:43 +00005460}
5461
5462ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation,
5463 Expr *Operand, SourceLocation RParen) {
5464 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
Sebastian Redl02bc21a2010-09-10 20:55:37 +00005465}
5466
Eli Friedmane26073c2012-05-24 22:04:19 +00005467static bool IsSpecialDiscardedValue(Expr *E) {
5468 // In C++11, discarded-value expressions of a certain form are special,
5469 // according to [expr]p10:
5470 // The lvalue-to-rvalue conversion (4.1) is applied only if the
5471 // expression is an lvalue of volatile-qualified type and it has
5472 // one of the following forms:
5473 E = E->IgnoreParens();
5474
Eli Friedman02180682012-05-24 22:36:31 +00005475 // - id-expression (5.1.1),
Eli Friedmane26073c2012-05-24 22:04:19 +00005476 if (isa<DeclRefExpr>(E))
5477 return true;
5478
Eli Friedman02180682012-05-24 22:36:31 +00005479 // - subscripting (5.2.1),
Eli Friedmane26073c2012-05-24 22:04:19 +00005480 if (isa<ArraySubscriptExpr>(E))
5481 return true;
5482
Eli Friedman02180682012-05-24 22:36:31 +00005483 // - class member access (5.2.5),
Eli Friedmane26073c2012-05-24 22:04:19 +00005484 if (isa<MemberExpr>(E))
5485 return true;
5486
Eli Friedman02180682012-05-24 22:36:31 +00005487 // - indirection (5.3.1),
Eli Friedmane26073c2012-05-24 22:04:19 +00005488 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
5489 if (UO->getOpcode() == UO_Deref)
5490 return true;
5491
5492 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
Eli Friedman02180682012-05-24 22:36:31 +00005493 // - pointer-to-member operation (5.5),
Eli Friedmane26073c2012-05-24 22:04:19 +00005494 if (BO->isPtrMemOp())
5495 return true;
5496
Eli Friedman02180682012-05-24 22:36:31 +00005497 // - comma expression (5.18) where the right operand is one of the above.
Eli Friedmane26073c2012-05-24 22:04:19 +00005498 if (BO->getOpcode() == BO_Comma)
5499 return IsSpecialDiscardedValue(BO->getRHS());
5500 }
5501
Eli Friedman02180682012-05-24 22:36:31 +00005502 // - conditional expression (5.16) where both the second and the third
Eli Friedmane26073c2012-05-24 22:04:19 +00005503 // operands are one of the above, or
5504 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
5505 return IsSpecialDiscardedValue(CO->getTrueExpr()) &&
5506 IsSpecialDiscardedValue(CO->getFalseExpr());
5507 // The related edge case of "*x ?: *x".
5508 if (BinaryConditionalOperator *BCO =
5509 dyn_cast<BinaryConditionalOperator>(E)) {
5510 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
5511 return IsSpecialDiscardedValue(OVE->getSourceExpr()) &&
5512 IsSpecialDiscardedValue(BCO->getFalseExpr());
5513 }
5514
5515 // Objective-C++ extensions to the rule.
5516 if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
5517 return true;
5518
5519 return false;
5520}
5521
John McCallf6a16482010-12-04 03:47:34 +00005522/// Perform the conversions required for an expression used in a
5523/// context that ignores the result.
John Wiegley429bb272011-04-08 18:41:53 +00005524ExprResult Sema::IgnoredValueConversions(Expr *E) {
John McCall3c3b7f92011-10-25 17:37:35 +00005525 if (E->hasPlaceholderType()) {
5526 ExprResult result = CheckPlaceholderExpr(E);
5527 if (result.isInvalid()) return Owned(E);
5528 E = result.take();
5529 }
5530
John McCalla878cda2010-12-02 02:07:15 +00005531 // C99 6.3.2.1:
5532 // [Except in specific positions,] an lvalue that does not have
5533 // array type is converted to the value stored in the
5534 // designated object (and is no longer an lvalue).
John McCalle6d134b2011-06-27 21:24:11 +00005535 if (E->isRValue()) {
5536 // In C, function designators (i.e. expressions of function type)
5537 // are r-values, but we still want to do function-to-pointer decay
5538 // on them. This is both technically correct and convenient for
5539 // some clients.
David Blaikie4e4d0842012-03-11 07:00:24 +00005540 if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType())
John McCalle6d134b2011-06-27 21:24:11 +00005541 return DefaultFunctionArrayConversion(E);
5542
5543 return Owned(E);
5544 }
John McCalla878cda2010-12-02 02:07:15 +00005545
Eli Friedmane26073c2012-05-24 22:04:19 +00005546 if (getLangOpts().CPlusPlus) {
5547 // The C++11 standard defines the notion of a discarded-value expression;
5548 // normally, we don't need to do anything to handle it, but if it is a
5549 // volatile lvalue with a special form, we perform an lvalue-to-rvalue
5550 // conversion.
Richard Smith80ad52f2013-01-02 11:42:31 +00005551 if (getLangOpts().CPlusPlus11 && E->isGLValue() &&
Eli Friedmane26073c2012-05-24 22:04:19 +00005552 E->getType().isVolatileQualified() &&
5553 IsSpecialDiscardedValue(E)) {
5554 ExprResult Res = DefaultLvalueConversion(E);
5555 if (Res.isInvalid())
5556 return Owned(E);
5557 E = Res.take();
5558 }
5559 return Owned(E);
5560 }
John McCallf6a16482010-12-04 03:47:34 +00005561
5562 // GCC seems to also exclude expressions of incomplete enum type.
5563 if (const EnumType *T = E->getType()->getAs<EnumType>()) {
5564 if (!T->getDecl()->isComplete()) {
5565 // FIXME: stupid workaround for a codegen bug!
John Wiegley429bb272011-04-08 18:41:53 +00005566 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).take();
5567 return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00005568 }
5569 }
5570
John Wiegley429bb272011-04-08 18:41:53 +00005571 ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
5572 if (Res.isInvalid())
5573 return Owned(E);
5574 E = Res.take();
5575
John McCall85515d62010-12-04 12:29:11 +00005576 if (!E->getType()->isVoidType())
5577 RequireCompleteType(E->getExprLoc(), E->getType(),
5578 diag::err_incomplete_type);
John Wiegley429bb272011-04-08 18:41:53 +00005579 return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00005580}
5581
Richard Smith41956372013-01-14 22:39:08 +00005582ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
Fariborz Jahanianad48a502013-01-24 22:11:45 +00005583 bool DiscardedValue,
5584 bool IsConstexpr) {
John Wiegley429bb272011-04-08 18:41:53 +00005585 ExprResult FullExpr = Owned(FE);
5586
5587 if (!FullExpr.get())
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00005588 return ExprError();
John McCallf6a16482010-12-04 03:47:34 +00005589
John Wiegley429bb272011-04-08 18:41:53 +00005590 if (DiagnoseUnexpandedParameterPack(FullExpr.get()))
Douglas Gregord0937222010-12-13 22:49:22 +00005591 return ExprError();
5592
Douglas Gregor1344e942013-03-07 22:57:58 +00005593 // Top-level expressions default to 'id' when we're in a debugger.
Richard Smith41956372013-01-14 22:39:08 +00005594 if (DiscardedValue && getLangOpts().DebuggerCastResultToId &&
Douglas Gregor1344e942013-03-07 22:57:58 +00005595 FullExpr.get()->getType() == Context.UnknownAnyTy) {
Douglas Gregor5e3a8be2011-12-15 00:53:32 +00005596 FullExpr = forceUnknownAnyToType(FullExpr.take(), Context.getObjCIdType());
5597 if (FullExpr.isInvalid())
5598 return ExprError();
5599 }
Douglas Gregor353ee242011-03-07 02:05:23 +00005600
Richard Smith41956372013-01-14 22:39:08 +00005601 if (DiscardedValue) {
5602 FullExpr = CheckPlaceholderExpr(FullExpr.take());
5603 if (FullExpr.isInvalid())
5604 return ExprError();
5605
5606 FullExpr = IgnoredValueConversions(FullExpr.take());
5607 if (FullExpr.isInvalid())
5608 return ExprError();
5609 }
John Wiegley429bb272011-04-08 18:41:53 +00005610
Fariborz Jahanianad48a502013-01-24 22:11:45 +00005611 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
John McCall4765fa02010-12-06 08:20:24 +00005612 return MaybeCreateExprWithCleanups(FullExpr);
Anders Carlsson165a0a02009-05-17 18:41:29 +00005613}
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00005614
5615StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
5616 if (!FullStmt) return StmtError();
5617
John McCall4765fa02010-12-06 08:20:24 +00005618 return MaybeCreateStmtWithCleanups(FullStmt);
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00005619}
Francois Pichet1e862692011-05-06 20:48:22 +00005620
Douglas Gregorba0513d2011-10-25 01:33:02 +00005621Sema::IfExistsResult
5622Sema::CheckMicrosoftIfExistsSymbol(Scope *S,
5623 CXXScopeSpec &SS,
5624 const DeclarationNameInfo &TargetNameInfo) {
Francois Pichet1e862692011-05-06 20:48:22 +00005625 DeclarationName TargetName = TargetNameInfo.getName();
5626 if (!TargetName)
Douglas Gregor3896fc52011-10-24 22:31:10 +00005627 return IER_DoesNotExist;
Douglas Gregorba0513d2011-10-25 01:33:02 +00005628
Douglas Gregor3896fc52011-10-24 22:31:10 +00005629 // If the name itself is dependent, then the result is dependent.
5630 if (TargetName.isDependentName())
5631 return IER_Dependent;
Douglas Gregorba0513d2011-10-25 01:33:02 +00005632
Francois Pichet1e862692011-05-06 20:48:22 +00005633 // Do the redeclaration lookup in the current scope.
5634 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
5635 Sema::NotForRedeclaration);
Douglas Gregor3896fc52011-10-24 22:31:10 +00005636 LookupParsedName(R, S, &SS);
Francois Pichet1e862692011-05-06 20:48:22 +00005637 R.suppressDiagnostics();
Douglas Gregor3896fc52011-10-24 22:31:10 +00005638
5639 switch (R.getResultKind()) {
5640 case LookupResult::Found:
5641 case LookupResult::FoundOverloaded:
5642 case LookupResult::FoundUnresolvedValue:
5643 case LookupResult::Ambiguous:
5644 return IER_Exists;
5645
5646 case LookupResult::NotFound:
5647 return IER_DoesNotExist;
5648
5649 case LookupResult::NotFoundInCurrentInstantiation:
5650 return IER_Dependent;
5651 }
David Blaikie7530c032012-01-17 06:56:22 +00005652
5653 llvm_unreachable("Invalid LookupResult Kind!");
Francois Pichet1e862692011-05-06 20:48:22 +00005654}
Douglas Gregorba0513d2011-10-25 01:33:02 +00005655
Douglas Gregor65019ac2011-10-25 03:44:56 +00005656Sema::IfExistsResult
5657Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
5658 bool IsIfExists, CXXScopeSpec &SS,
5659 UnqualifiedId &Name) {
Douglas Gregorba0513d2011-10-25 01:33:02 +00005660 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
Douglas Gregor65019ac2011-10-25 03:44:56 +00005661
5662 // Check for unexpanded parameter packs.
5663 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
5664 collectUnexpandedParameterPacks(SS, Unexpanded);
5665 collectUnexpandedParameterPacks(TargetNameInfo, Unexpanded);
5666 if (!Unexpanded.empty()) {
5667 DiagnoseUnexpandedParameterPacks(KeywordLoc,
5668 IsIfExists? UPPC_IfExists
5669 : UPPC_IfNotExists,
5670 Unexpanded);
5671 return IER_Error;
5672 }
5673
Douglas Gregorba0513d2011-10-25 01:33:02 +00005674 return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
5675}