blob: af30061e28a197686811d3c4ce459d7851be8281 [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//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ expressions.
11//
12//===----------------------------------------------------------------------===//
13
John McCall2d887082010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
John McCall2a7fb272010-08-25 05:32:35 +000015#include "clang/Sema/DeclSpec.h"
Douglas Gregore737f502010-08-12 20:07:10 +000016#include "clang/Sema/Initialization.h"
17#include "clang/Sema/Lookup.h"
John McCall2a7fb272010-08-25 05:32:35 +000018#include "clang/Sema/ParsedTemplate.h"
John McCall469a1eb2011-02-02 13:00:07 +000019#include "clang/Sema/ScopeInfo.h"
John McCall2a7fb272010-08-25 05:32:35 +000020#include "clang/Sema/TemplateDeduction.h"
Steve Naroff210679c2007-08-25 14:02:58 +000021#include "clang/AST/ASTContext.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000022#include "clang/AST/CXXInheritance.h"
John McCall7cd088e2010-08-24 07:21:54 +000023#include "clang/AST/DeclObjC.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000024#include "clang/AST/ExprCXX.h"
Fariborz Jahaniand4266622010-06-16 18:56:04 +000025#include "clang/AST/ExprObjC.h"
Douglas Gregorb57fb492010-02-24 22:38:50 +000026#include "clang/AST/TypeLoc.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000027#include "clang/Basic/PartialDiagnostic.h"
Sebastian Redlb5a57a62008-12-03 20:26:15 +000028#include "clang/Basic/TargetInfo.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000029#include "clang/Lex/Preprocessor.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000030#include "llvm/ADT/STLExtras.h"
Chandler Carruth73e0a912011-05-01 07:23:17 +000031#include "llvm/Support/ErrorHandling.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
John McCall2a7fb272010-08-25 05:32:35 +000033using namespace sema;
Reid Spencer5f016e22007-07-11 17:01:13 +000034
John McCallb3d87482010-08-24 05:47:05 +000035ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000036 IdentifierInfo &II,
John McCallb3d87482010-08-24 05:47:05 +000037 SourceLocation NameLoc,
38 Scope *S, CXXScopeSpec &SS,
39 ParsedType ObjectTypePtr,
40 bool EnteringContext) {
Douglas Gregor124b8782010-02-16 19:09:40 +000041 // Determine where to perform name lookup.
42
43 // FIXME: This area of the standard is very messy, and the current
44 // wording is rather unclear about which scopes we search for the
45 // destructor name; see core issues 399 and 555. Issue 399 in
46 // particular shows where the current description of destructor name
47 // lookup is completely out of line with existing practice, e.g.,
48 // this appears to be ill-formed:
49 //
50 // namespace N {
51 // template <typename T> struct S {
52 // ~S();
53 // };
54 // }
55 //
56 // void f(N::S<int>* s) {
57 // s->N::S<int>::~S();
58 // }
59 //
Douglas Gregor93649fd2010-02-23 00:15:22 +000060 // See also PR6358 and PR6359.
Sebastian Redlc0fee502010-07-07 23:17:38 +000061 // For this reason, we're currently only doing the C++03 version of this
62 // code; the C++0x version has to wait until we get a proper spec.
Douglas Gregor124b8782010-02-16 19:09:40 +000063 QualType SearchType;
64 DeclContext *LookupCtx = 0;
65 bool isDependent = false;
66 bool LookInScope = false;
67
68 // If we have an object type, it's because we are in a
69 // pseudo-destructor-expression or a member access expression, and
70 // we know what type we're looking for.
71 if (ObjectTypePtr)
72 SearchType = GetTypeFromParser(ObjectTypePtr);
73
74 if (SS.isSet()) {
Douglas Gregor93649fd2010-02-23 00:15:22 +000075 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000076
Douglas Gregor93649fd2010-02-23 00:15:22 +000077 bool AlreadySearched = false;
78 bool LookAtPrefix = true;
Sebastian Redlc0fee502010-07-07 23:17:38 +000079 // C++ [basic.lookup.qual]p6:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000080 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
Sebastian Redlc0fee502010-07-07 23:17:38 +000081 // the type-names are looked up as types in the scope designated by the
82 // nested-name-specifier. In a qualified-id of the form:
NAKAMURA Takumi00995302011-01-27 07:09:49 +000083 //
84 // ::[opt] nested-name-specifier ~ class-name
Sebastian Redlc0fee502010-07-07 23:17:38 +000085 //
86 // where the nested-name-specifier designates a namespace scope, and in
Chandler Carruth5e895a82010-02-21 10:19:54 +000087 // a qualified-id of the form:
Douglas Gregor124b8782010-02-16 19:09:40 +000088 //
NAKAMURA Takumi00995302011-01-27 07:09:49 +000089 // ::opt nested-name-specifier class-name :: ~ class-name
Douglas Gregor124b8782010-02-16 19:09:40 +000090 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000091 // the class-names are looked up as types in the scope designated by
Sebastian Redlc0fee502010-07-07 23:17:38 +000092 // the nested-name-specifier.
Douglas Gregor124b8782010-02-16 19:09:40 +000093 //
Sebastian Redlc0fee502010-07-07 23:17:38 +000094 // Here, we check the first case (completely) and determine whether the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000095 // code below is permitted to look at the prefix of the
Sebastian Redlc0fee502010-07-07 23:17:38 +000096 // nested-name-specifier.
97 DeclContext *DC = computeDeclContext(SS, EnteringContext);
98 if (DC && DC->isFileContext()) {
99 AlreadySearched = true;
100 LookupCtx = DC;
101 isDependent = false;
102 } else if (DC && isa<CXXRecordDecl>(DC))
103 LookAtPrefix = false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000104
Sebastian Redlc0fee502010-07-07 23:17:38 +0000105 // The second case from the C++03 rules quoted further above.
Douglas Gregor93649fd2010-02-23 00:15:22 +0000106 NestedNameSpecifier *Prefix = 0;
107 if (AlreadySearched) {
108 // Nothing left to do.
109 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
110 CXXScopeSpec PrefixSS;
Douglas Gregor7e384942011-02-25 16:07:42 +0000111 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
Douglas Gregor93649fd2010-02-23 00:15:22 +0000112 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
113 isDependent = isDependentScopeSpecifier(PrefixSS);
Douglas Gregor93649fd2010-02-23 00:15:22 +0000114 } else if (ObjectTypePtr) {
Douglas Gregor124b8782010-02-16 19:09:40 +0000115 LookupCtx = computeDeclContext(SearchType);
116 isDependent = SearchType->isDependentType();
117 } else {
118 LookupCtx = computeDeclContext(SS, EnteringContext);
Douglas Gregor93649fd2010-02-23 00:15:22 +0000119 isDependent = LookupCtx && LookupCtx->isDependentContext();
Douglas Gregor124b8782010-02-16 19:09:40 +0000120 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000121
Douglas Gregoredc90502010-02-25 04:46:04 +0000122 LookInScope = false;
Douglas Gregor124b8782010-02-16 19:09:40 +0000123 } else if (ObjectTypePtr) {
124 // C++ [basic.lookup.classref]p3:
125 // If the unqualified-id is ~type-name, the type-name is looked up
126 // in the context of the entire postfix-expression. If the type T
127 // of the object expression is of a class type C, the type-name is
128 // also looked up in the scope of class C. At least one of the
129 // lookups shall find a name that refers to (possibly
130 // cv-qualified) T.
131 LookupCtx = computeDeclContext(SearchType);
132 isDependent = SearchType->isDependentType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000133 assert((isDependent || !SearchType->isIncompleteType()) &&
Douglas Gregor124b8782010-02-16 19:09:40 +0000134 "Caller should have completed object type");
135
136 LookInScope = true;
137 } else {
138 // Perform lookup into the current scope (only).
139 LookInScope = true;
140 }
141
Douglas Gregor7ec18732011-03-04 22:32:08 +0000142 TypeDecl *NonMatchingTypeDecl = 0;
Douglas Gregor124b8782010-02-16 19:09:40 +0000143 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
144 for (unsigned Step = 0; Step != 2; ++Step) {
145 // Look for the name first in the computed lookup context (if we
Douglas Gregor7ec18732011-03-04 22:32:08 +0000146 // have one) and, if that fails to find a match, in the scope (if
Douglas Gregor124b8782010-02-16 19:09:40 +0000147 // we're allowed to look there).
148 Found.clear();
149 if (Step == 0 && LookupCtx)
150 LookupQualifiedName(Found, LookupCtx);
Douglas Gregora2e7dd22010-02-25 01:56:36 +0000151 else if (Step == 1 && LookInScope && S)
Douglas Gregor124b8782010-02-16 19:09:40 +0000152 LookupName(Found, S);
153 else
154 continue;
155
156 // FIXME: Should we be suppressing ambiguities here?
157 if (Found.isAmbiguous())
John McCallb3d87482010-08-24 05:47:05 +0000158 return ParsedType();
Douglas Gregor124b8782010-02-16 19:09:40 +0000159
160 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
161 QualType T = Context.getTypeDeclType(Type);
Douglas Gregor124b8782010-02-16 19:09:40 +0000162
163 if (SearchType.isNull() || SearchType->isDependentType() ||
164 Context.hasSameUnqualifiedType(T, SearchType)) {
165 // We found our type!
166
John McCallb3d87482010-08-24 05:47:05 +0000167 return ParsedType::make(T);
Douglas Gregor124b8782010-02-16 19:09:40 +0000168 }
John Wiegley36784e72011-03-08 08:13:22 +0000169
Douglas Gregor7ec18732011-03-04 22:32:08 +0000170 if (!SearchType.isNull())
171 NonMatchingTypeDecl = Type;
Douglas Gregor124b8782010-02-16 19:09:40 +0000172 }
173
174 // If the name that we found is a class template name, and it is
175 // the same name as the template name in the last part of the
176 // nested-name-specifier (if present) or the object type, then
177 // this is the destructor for that class.
178 // FIXME: This is a workaround until we get real drafting for core
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000179 // issue 399, for which there isn't even an obvious direction.
Douglas Gregor124b8782010-02-16 19:09:40 +0000180 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
181 QualType MemberOfType;
182 if (SS.isSet()) {
183 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
184 // Figure out the type of the context, if it has one.
John McCall3cb0ebd2010-03-10 03:28:59 +0000185 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
186 MemberOfType = Context.getTypeDeclType(Record);
Douglas Gregor124b8782010-02-16 19:09:40 +0000187 }
188 }
189 if (MemberOfType.isNull())
190 MemberOfType = SearchType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000191
Douglas Gregor124b8782010-02-16 19:09:40 +0000192 if (MemberOfType.isNull())
193 continue;
194
195 // We're referring into a class template specialization. If the
196 // class template we found is the same as the template being
197 // specialized, we found what we are looking for.
198 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
199 if (ClassTemplateSpecializationDecl *Spec
200 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
201 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
202 Template->getCanonicalDecl())
John McCallb3d87482010-08-24 05:47:05 +0000203 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000204 }
205
206 continue;
207 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000208
Douglas Gregor124b8782010-02-16 19:09:40 +0000209 // We're referring to an unresolved class template
210 // specialization. Determine whether we class template we found
211 // is the same as the template being specialized or, if we don't
212 // know which template is being specialized, that it at least
213 // has the same name.
214 if (const TemplateSpecializationType *SpecType
215 = MemberOfType->getAs<TemplateSpecializationType>()) {
216 TemplateName SpecName = SpecType->getTemplateName();
217
218 // The class template we found is the same template being
219 // specialized.
220 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
221 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
John McCallb3d87482010-08-24 05:47:05 +0000222 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000223
224 continue;
225 }
226
227 // The class template we found has the same name as the
228 // (dependent) template name being specialized.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000229 if (DependentTemplateName *DepTemplate
Douglas Gregor124b8782010-02-16 19:09:40 +0000230 = SpecName.getAsDependentTemplateName()) {
231 if (DepTemplate->isIdentifier() &&
232 DepTemplate->getIdentifier() == Template->getIdentifier())
John McCallb3d87482010-08-24 05:47:05 +0000233 return ParsedType::make(MemberOfType);
Douglas Gregor124b8782010-02-16 19:09:40 +0000234
235 continue;
236 }
237 }
238 }
239 }
240
241 if (isDependent) {
242 // We didn't find our type, but that's okay: it's dependent
243 // anyway.
Douglas Gregore29425b2011-02-28 22:42:13 +0000244
245 // FIXME: What if we have no nested-name-specifier?
246 QualType T = CheckTypenameType(ETK_None, SourceLocation(),
247 SS.getWithLocInContext(Context),
248 II, NameLoc);
John McCallb3d87482010-08-24 05:47:05 +0000249 return ParsedType::make(T);
Douglas Gregor124b8782010-02-16 19:09:40 +0000250 }
251
Douglas Gregor7ec18732011-03-04 22:32:08 +0000252 if (NonMatchingTypeDecl) {
253 QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
254 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
255 << T << SearchType;
256 Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
257 << T;
258 } else if (ObjectTypePtr)
259 Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000260 << &II;
Douglas Gregor124b8782010-02-16 19:09:40 +0000261 else
262 Diag(NameLoc, diag::err_destructor_class_name);
263
John McCallb3d87482010-08-24 05:47:05 +0000264 return ParsedType();
Douglas Gregor124b8782010-02-16 19:09:40 +0000265}
266
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000267/// \brief Build a C++ typeid expression with a type operand.
John McCall60d7b3a2010-08-24 06:29:42 +0000268ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000269 SourceLocation TypeidLoc,
270 TypeSourceInfo *Operand,
271 SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000272 // C++ [expr.typeid]p4:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000273 // The top-level cv-qualifiers of the lvalue expression or the type-id
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000274 // that is the operand of typeid are always ignored.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000275 // If the type of the type-id is a class type or a reference to a class
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000276 // type, the class shall be completely-defined.
Douglas Gregord1c1d7b2010-06-02 06:16:02 +0000277 Qualifiers Quals;
278 QualType T
279 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
280 Quals);
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000281 if (T->getAs<RecordType>() &&
282 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
283 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000284
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000285 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
286 Operand,
287 SourceRange(TypeidLoc, RParenLoc)));
288}
289
290/// \brief Build a C++ typeid expression with an expression operand.
John McCall60d7b3a2010-08-24 06:29:42 +0000291ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000292 SourceLocation TypeidLoc,
293 Expr *E,
294 SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000295 bool isUnevaluatedOperand = true;
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000296 if (E && !E->isTypeDependent()) {
297 QualType T = E->getType();
298 if (const RecordType *RecordT = T->getAs<RecordType>()) {
299 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
300 // C++ [expr.typeid]p3:
301 // [...] If the type of the expression is a class type, the class
302 // shall be completely-defined.
303 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
304 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000305
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000306 // C++ [expr.typeid]p3:
Sebastian Redl906082e2010-07-20 04:20:21 +0000307 // When typeid is applied to an expression other than an glvalue of a
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000308 // polymorphic class type [...] [the] expression is an unevaluated
309 // operand. [...]
Sebastian Redl906082e2010-07-20 04:20:21 +0000310 if (RecordD->isPolymorphic() && E->Classify(Context).isGLValue()) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000311 isUnevaluatedOperand = false;
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000312
313 // We require a vtable to query the type at run time.
314 MarkVTableUsed(TypeidLoc, RecordD);
315 }
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000316 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000317
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000318 // C++ [expr.typeid]p4:
319 // [...] If the type of the type-id is a reference to a possibly
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000320 // cv-qualified type, the result of the typeid expression refers to a
321 // std::type_info object representing the cv-unqualified referenced
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000322 // type.
Douglas Gregord1c1d7b2010-06-02 06:16:02 +0000323 Qualifiers Quals;
324 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
325 if (!Context.hasSameType(T, UnqualT)) {
326 T = UnqualT;
John Wiegley429bb272011-04-08 18:41:53 +0000327 E = ImpCastExprToType(E, UnqualT, CK_NoOp, CastCategory(E)).take();
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000328 }
329 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000330
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000331 // If this is an unevaluated operand, clear out the set of
332 // declaration references we have been computing and eliminate any
333 // temporaries introduced in its computation.
334 if (isUnevaluatedOperand)
335 ExprEvalContexts.back().Context = Unevaluated;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000336
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000337 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
John McCall9ae2f072010-08-23 23:25:46 +0000338 E,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000339 SourceRange(TypeidLoc, RParenLoc)));
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000340}
341
342/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
John McCall60d7b3a2010-08-24 06:29:42 +0000343ExprResult
Sebastian Redlc42e1182008-11-11 11:37:55 +0000344Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
345 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000346 // Find the std::type_info type.
Sebastian Redlce0682f2011-03-31 19:29:24 +0000347 if (!getStdNamespace())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000348 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000349
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000350 if (!CXXTypeInfoDecl) {
351 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
352 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
353 LookupQualifiedName(R, getStdNamespace());
354 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
355 if (!CXXTypeInfoDecl)
356 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
357 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000358
Douglas Gregor4eb4f0f2010-09-08 23:14:30 +0000359 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000360
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000361 if (isType) {
362 // The operand is a type; handle it as such.
363 TypeSourceInfo *TInfo = 0;
John McCallb3d87482010-08-24 05:47:05 +0000364 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
365 &TInfo);
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000366 if (T.isNull())
367 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000368
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000369 if (!TInfo)
370 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +0000371
Douglas Gregor57fdc8a2010-04-26 22:37:10 +0000372 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
Douglas Gregorac7610d2009-06-22 20:57:11 +0000373 }
Mike Stump1eb44332009-09-09 15:08:12 +0000374
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000375 // The operand is an expression.
John McCall9ae2f072010-08-23 23:25:46 +0000376 return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +0000377}
378
Francois Pichet6915c522010-12-27 01:32:00 +0000379/// Retrieve the UuidAttr associated with QT.
380static UuidAttr *GetUuidAttrOfType(QualType QT) {
381 // Optionally remove one level of pointer, reference or array indirection.
John McCallf4c73712011-01-19 06:33:43 +0000382 const Type *Ty = QT.getTypePtr();;
Francois Pichet913b7bf2010-12-20 03:51:03 +0000383 if (QT->isPointerType() || QT->isReferenceType())
384 Ty = QT->getPointeeType().getTypePtr();
385 else if (QT->isArrayType())
386 Ty = cast<ArrayType>(QT)->getElementType().getTypePtr();
387
Francois Pichet8db75a22011-05-08 10:02:20 +0000388 // Loop all record redeclaration looking for an uuid attribute.
Francois Pichet6915c522010-12-27 01:32:00 +0000389 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
Francois Pichet8db75a22011-05-08 10:02:20 +0000390 for (CXXRecordDecl::redecl_iterator I = RD->redecls_begin(),
391 E = RD->redecls_end(); I != E; ++I) {
392 if (UuidAttr *Uuid = I->getAttr<UuidAttr>())
Francois Pichet6915c522010-12-27 01:32:00 +0000393 return Uuid;
Francois Pichet6915c522010-12-27 01:32:00 +0000394 }
Francois Pichet8db75a22011-05-08 10:02:20 +0000395
Francois Pichet6915c522010-12-27 01:32:00 +0000396 return 0;
Francois Pichet913b7bf2010-12-20 03:51:03 +0000397}
398
Francois Pichet01b7c302010-09-08 12:20:18 +0000399/// \brief Build a Microsoft __uuidof expression with a type operand.
400ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
401 SourceLocation TypeidLoc,
402 TypeSourceInfo *Operand,
403 SourceLocation RParenLoc) {
Francois Pichet6915c522010-12-27 01:32:00 +0000404 if (!Operand->getType()->isDependentType()) {
405 if (!GetUuidAttrOfType(Operand->getType()))
406 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
407 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000408
Francois Pichet01b7c302010-09-08 12:20:18 +0000409 // FIXME: add __uuidof semantic analysis for type operand.
410 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(),
411 Operand,
412 SourceRange(TypeidLoc, RParenLoc)));
413}
414
415/// \brief Build a Microsoft __uuidof expression with an expression operand.
416ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
417 SourceLocation TypeidLoc,
418 Expr *E,
419 SourceLocation RParenLoc) {
Francois Pichet6915c522010-12-27 01:32:00 +0000420 if (!E->getType()->isDependentType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000421 if (!GetUuidAttrOfType(E->getType()) &&
Francois Pichet6915c522010-12-27 01:32:00 +0000422 !E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
423 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
424 }
425 // FIXME: add __uuidof semantic analysis for type operand.
Francois Pichet01b7c302010-09-08 12:20:18 +0000426 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(),
427 E,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000428 SourceRange(TypeidLoc, RParenLoc)));
Francois Pichet01b7c302010-09-08 12:20:18 +0000429}
430
431/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
432ExprResult
433Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
434 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000435 // If MSVCGuidDecl has not been cached, do the lookup.
Francois Pichet01b7c302010-09-08 12:20:18 +0000436 if (!MSVCGuidDecl) {
437 IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
438 LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
439 LookupQualifiedName(R, Context.getTranslationUnitDecl());
440 MSVCGuidDecl = R.getAsSingle<RecordDecl>();
441 if (!MSVCGuidDecl)
442 return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000443 }
444
Francois Pichet01b7c302010-09-08 12:20:18 +0000445 QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000446
Francois Pichet01b7c302010-09-08 12:20:18 +0000447 if (isType) {
448 // The operand is a type; handle it as such.
449 TypeSourceInfo *TInfo = 0;
450 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
451 &TInfo);
452 if (T.isNull())
453 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000454
Francois Pichet01b7c302010-09-08 12:20:18 +0000455 if (!TInfo)
456 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
457
458 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
459 }
460
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000461 // The operand is an expression.
Francois Pichet01b7c302010-09-08 12:20:18 +0000462 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
463}
464
Steve Naroff1b273c42007-09-16 14:56:35 +0000465/// ActOnCXXBoolLiteral - Parse {true,false} literals.
John McCall60d7b3a2010-08-24 06:29:42 +0000466ExprResult
Steve Naroff1b273c42007-09-16 14:56:35 +0000467Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
Douglas Gregor2f639b92008-10-24 15:36:09 +0000468 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
Reid Spencer5f016e22007-07-11 17:01:13 +0000469 "Unknown C++ Boolean value!");
Sebastian Redlf53597f2009-03-15 17:47:39 +0000470 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
471 Context.BoolTy, OpLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +0000472}
Chris Lattner50dd2892008-02-26 00:51:44 +0000473
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000474/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
John McCall60d7b3a2010-08-24 06:29:42 +0000475ExprResult
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000476Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
477 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
478}
479
Chris Lattner50dd2892008-02-26 00:51:44 +0000480/// ActOnCXXThrow - Parse throw expressions.
John McCall60d7b3a2010-08-24 06:29:42 +0000481ExprResult
John McCall9ae2f072010-08-23 23:25:46 +0000482Sema::ActOnCXXThrow(SourceLocation OpLoc, Expr *Ex) {
Anders Carlsson729b8532011-02-23 03:46:46 +0000483 // Don't report an error if 'throw' is used in system headers.
Anders Carlsson15348ae2011-02-28 02:27:16 +0000484 if (!getLangOptions().CXXExceptions &&
Anders Carlsson729b8532011-02-23 03:46:46 +0000485 !getSourceManager().isInSystemHeader(OpLoc))
Anders Carlssonb1fba312011-02-19 21:53:09 +0000486 Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
Anders Carlsson7f11d9c2011-02-19 19:26:44 +0000487
John Wiegley429bb272011-04-08 18:41:53 +0000488 if (Ex && !Ex->isTypeDependent()) {
489 ExprResult ExRes = CheckCXXThrowOperand(OpLoc, Ex);
490 if (ExRes.isInvalid())
491 return ExprError();
492 Ex = ExRes.take();
493 }
Sebastian Redl972041f2009-04-27 20:27:31 +0000494 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc));
495}
496
497/// CheckCXXThrowOperand - Validate the operand of a throw.
John Wiegley429bb272011-04-08 18:41:53 +0000498ExprResult Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *E) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000499 // C++ [except.throw]p3:
Douglas Gregor154fe982009-12-23 22:04:40 +0000500 // A throw-expression initializes a temporary object, called the exception
501 // object, the type of which is determined by removing any top-level
502 // cv-qualifiers from the static type of the operand of throw and adjusting
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000503 // the type from "array of T" or "function returning T" to "pointer to T"
Douglas Gregor154fe982009-12-23 22:04:40 +0000504 // or "pointer to function returning T", [...]
505 if (E->getType().hasQualifiers())
John Wiegley429bb272011-04-08 18:41:53 +0000506 E = ImpCastExprToType(E, E->getType().getUnqualifiedType(), CK_NoOp,
507 CastCategory(E)).take();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000508
John Wiegley429bb272011-04-08 18:41:53 +0000509 ExprResult Res = DefaultFunctionArrayConversion(E);
510 if (Res.isInvalid())
511 return ExprError();
512 E = Res.take();
Sebastian Redl972041f2009-04-27 20:27:31 +0000513
514 // If the type of the exception would be an incomplete type or a pointer
515 // to an incomplete type other than (cv) void the program is ill-formed.
516 QualType Ty = E->getType();
John McCallac418162010-04-22 01:10:34 +0000517 bool isPointer = false;
Ted Kremenek6217b802009-07-29 21:53:49 +0000518 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000519 Ty = Ptr->getPointeeType();
John McCallac418162010-04-22 01:10:34 +0000520 isPointer = true;
Sebastian Redl972041f2009-04-27 20:27:31 +0000521 }
522 if (!isPointer || !Ty->isVoidType()) {
523 if (RequireCompleteType(ThrowLoc, Ty,
Anders Carlssond497ba72009-08-26 22:59:12 +0000524 PDiag(isPointer ? diag::err_throw_incomplete_ptr
525 : diag::err_throw_incomplete)
526 << E->getSourceRange()))
John Wiegley429bb272011-04-08 18:41:53 +0000527 return ExprError();
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000528
Douglas Gregorbf422f92010-04-15 18:05:39 +0000529 if (RequireNonAbstractType(ThrowLoc, E->getType(),
530 PDiag(diag::err_throw_abstract_type)
531 << E->getSourceRange()))
John Wiegley429bb272011-04-08 18:41:53 +0000532 return ExprError();
Sebastian Redl972041f2009-04-27 20:27:31 +0000533 }
534
John McCallac418162010-04-22 01:10:34 +0000535 // Initialize the exception result. This implicitly weeds out
536 // abstract types or types with inaccessible copy constructors.
Douglas Gregor72dfa272011-01-21 22:46:35 +0000537 const VarDecl *NRVOVariable = getCopyElisionCandidate(QualType(), E, false);
538
Douglas Gregorf5d8f462011-01-21 18:05:27 +0000539 // FIXME: Determine whether we can elide this copy per C++0x [class.copy]p32.
John McCallac418162010-04-22 01:10:34 +0000540 InitializedEntity Entity =
Douglas Gregor72dfa272011-01-21 22:46:35 +0000541 InitializedEntity::InitializeException(ThrowLoc, E->getType(),
542 /*NRVO=*/false);
John Wiegley429bb272011-04-08 18:41:53 +0000543 Res = PerformMoveOrCopyInitialization(Entity, NRVOVariable,
544 QualType(), E);
John McCallac418162010-04-22 01:10:34 +0000545 if (Res.isInvalid())
John Wiegley429bb272011-04-08 18:41:53 +0000546 return ExprError();
547 E = Res.take();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000548
Eli Friedman5ed9b932010-06-03 20:39:03 +0000549 // If the exception has class type, we need additional handling.
550 const RecordType *RecordTy = Ty->getAs<RecordType>();
551 if (!RecordTy)
John Wiegley429bb272011-04-08 18:41:53 +0000552 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000553 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
554
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000555 // If we are throwing a polymorphic class type or pointer thereof,
556 // exception handling will make use of the vtable.
Eli Friedman5ed9b932010-06-03 20:39:03 +0000557 MarkVTableUsed(ThrowLoc, RD);
558
Eli Friedman98efb9f2010-10-12 20:32:36 +0000559 // If a pointer is thrown, the referenced object will not be destroyed.
560 if (isPointer)
John Wiegley429bb272011-04-08 18:41:53 +0000561 return Owned(E);
Eli Friedman98efb9f2010-10-12 20:32:36 +0000562
Eli Friedman5ed9b932010-06-03 20:39:03 +0000563 // If the class has a non-trivial destructor, we must be able to call it.
564 if (RD->hasTrivialDestructor())
John Wiegley429bb272011-04-08 18:41:53 +0000565 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000566
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000567 CXXDestructorDecl *Destructor
Douglas Gregordb89f282010-07-01 22:47:18 +0000568 = const_cast<CXXDestructorDecl*>(LookupDestructor(RD));
Eli Friedman5ed9b932010-06-03 20:39:03 +0000569 if (!Destructor)
John Wiegley429bb272011-04-08 18:41:53 +0000570 return Owned(E);
Eli Friedman5ed9b932010-06-03 20:39:03 +0000571
572 MarkDeclarationReferenced(E->getExprLoc(), Destructor);
573 CheckDestructorAccess(E->getExprLoc(), Destructor,
Douglas Gregored8abf12010-07-08 06:14:04 +0000574 PDiag(diag::err_access_dtor_exception) << Ty);
John Wiegley429bb272011-04-08 18:41:53 +0000575 return Owned(E);
Chris Lattner50dd2892008-02-26 00:51:44 +0000576}
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000577
John McCall5808ce42011-02-03 08:15:49 +0000578CXXMethodDecl *Sema::tryCaptureCXXThis() {
579 // Ignore block scopes: we can capture through them.
580 // Ignore nested enum scopes: we'll diagnose non-constant expressions
581 // where they're invalid, and other uses are legitimate.
582 // Don't ignore nested class scopes: you can't use 'this' in a local class.
John McCall469a1eb2011-02-02 13:00:07 +0000583 DeclContext *DC = CurContext;
John McCall5808ce42011-02-03 08:15:49 +0000584 while (true) {
585 if (isa<BlockDecl>(DC)) DC = cast<BlockDecl>(DC)->getDeclContext();
586 else if (isa<EnumDecl>(DC)) DC = cast<EnumDecl>(DC)->getDeclContext();
587 else break;
588 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000589
John McCall5808ce42011-02-03 08:15:49 +0000590 // If we're not in an instance method, error out.
John McCall469a1eb2011-02-02 13:00:07 +0000591 CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC);
592 if (!method || !method->isInstance())
John McCall5808ce42011-02-03 08:15:49 +0000593 return 0;
John McCall469a1eb2011-02-02 13:00:07 +0000594
595 // Mark that we're closing on 'this' in all the block scopes, if applicable.
596 for (unsigned idx = FunctionScopes.size() - 1;
597 isa<BlockScopeInfo>(FunctionScopes[idx]);
598 --idx)
599 cast<BlockScopeInfo>(FunctionScopes[idx])->CapturesCXXThis = true;
600
John McCall5808ce42011-02-03 08:15:49 +0000601 return method;
602}
603
604ExprResult Sema::ActOnCXXThis(SourceLocation loc) {
605 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
606 /// is a non-lvalue expression whose value is the address of the object for
607 /// which the function is called.
608
609 CXXMethodDecl *method = tryCaptureCXXThis();
610 if (!method) return Diag(loc, diag::err_invalid_this_use);
611
612 return Owned(new (Context) CXXThisExpr(loc, method->getThisType(Context),
John McCall469a1eb2011-02-02 13:00:07 +0000613 /*isImplicit=*/false));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000614}
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000615
John McCall60d7b3a2010-08-24 06:29:42 +0000616ExprResult
Douglas Gregorab6677e2010-09-08 00:15:04 +0000617Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000618 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000619 MultiExprArg exprs,
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000620 SourceLocation RParenLoc) {
Douglas Gregorae4c77d2010-02-05 19:11:37 +0000621 if (!TypeRep)
622 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000623
John McCall9d125032010-01-15 18:39:57 +0000624 TypeSourceInfo *TInfo;
625 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
626 if (!TInfo)
627 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
Douglas Gregorab6677e2010-09-08 00:15:04 +0000628
629 return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
630}
631
632/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
633/// Can be interpreted either as function-style casting ("int(x)")
634/// or class type construction ("ClassType(x,y,z)")
635/// or creation of a value-initialized type ("int()").
636ExprResult
637Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
638 SourceLocation LParenLoc,
639 MultiExprArg exprs,
640 SourceLocation RParenLoc) {
641 QualType Ty = TInfo->getType();
Sebastian Redlf53597f2009-03-15 17:47:39 +0000642 unsigned NumExprs = exprs.size();
643 Expr **Exprs = (Expr**)exprs.get();
Douglas Gregorab6677e2010-09-08 00:15:04 +0000644 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000645 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc);
646
Sebastian Redlf53597f2009-03-15 17:47:39 +0000647 if (Ty->isDependentType() ||
Douglas Gregorba498172009-03-13 21:01:28 +0000648 CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) {
Sebastian Redlf53597f2009-03-15 17:47:39 +0000649 exprs.release();
Mike Stump1eb44332009-09-09 15:08:12 +0000650
Douglas Gregorab6677e2010-09-08 00:15:04 +0000651 return Owned(CXXUnresolvedConstructExpr::Create(Context, TInfo,
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000652 LParenLoc,
653 Exprs, NumExprs,
654 RParenLoc));
Douglas Gregorba498172009-03-13 21:01:28 +0000655 }
656
Anders Carlssonbb60a502009-08-27 03:53:50 +0000657 if (Ty->isArrayType())
658 return ExprError(Diag(TyBeginLoc,
659 diag::err_value_init_for_array_type) << FullRange);
660 if (!Ty->isVoidType() &&
661 RequireCompleteType(TyBeginLoc, Ty,
662 PDiag(diag::err_invalid_incomplete_type_use)
663 << FullRange))
664 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000665
Anders Carlssonbb60a502009-08-27 03:53:50 +0000666 if (RequireNonAbstractType(TyBeginLoc, Ty,
667 diag::err_allocation_of_abstract_type))
668 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +0000669
670
Douglas Gregor506ae412009-01-16 18:33:17 +0000671 // C++ [expr.type.conv]p1:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000672 // If the expression list is a single expression, the type conversion
673 // expression is equivalent (in definedness, and if defined in meaning) to the
674 // corresponding cast expression.
675 //
676 if (NumExprs == 1) {
John McCalldaa8e4e2010-11-15 09:13:47 +0000677 CastKind Kind = CK_Invalid;
John McCallf89e55a2010-11-18 06:31:45 +0000678 ExprValueKind VK = VK_RValue;
John McCallf871d0c2010-08-07 06:22:56 +0000679 CXXCastPath BasePath;
John Wiegley429bb272011-04-08 18:41:53 +0000680 ExprResult CastExpr =
681 CheckCastTypes(TInfo->getTypeLoc().getSourceRange(), Ty, Exprs[0],
682 Kind, VK, BasePath,
683 /*FunctionalStyle=*/true);
684 if (CastExpr.isInvalid())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000685 return ExprError();
John Wiegley429bb272011-04-08 18:41:53 +0000686 Exprs[0] = CastExpr.take();
Anders Carlsson0aebc812009-09-09 21:33:21 +0000687
688 exprs.release();
Anders Carlsson0aebc812009-09-09 21:33:21 +0000689
John McCallf871d0c2010-08-07 06:22:56 +0000690 return Owned(CXXFunctionalCastExpr::Create(Context,
Douglas Gregorab6677e2010-09-08 00:15:04 +0000691 Ty.getNonLValueExprType(Context),
John McCallf89e55a2010-11-18 06:31:45 +0000692 VK, TInfo, TyBeginLoc, Kind,
John McCallf871d0c2010-08-07 06:22:56 +0000693 Exprs[0], &BasePath,
694 RParenLoc));
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000695 }
696
Douglas Gregor19311e72010-09-08 21:40:08 +0000697 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
698 InitializationKind Kind
699 = NumExprs ? InitializationKind::CreateDirect(TyBeginLoc,
700 LParenLoc, RParenLoc)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000701 : InitializationKind::CreateValue(TyBeginLoc,
Douglas Gregor19311e72010-09-08 21:40:08 +0000702 LParenLoc, RParenLoc);
703 InitializationSequence InitSeq(*this, Entity, Kind, Exprs, NumExprs);
704 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, move(exprs));
Sebastian Redlf53597f2009-03-15 17:47:39 +0000705
Douglas Gregor19311e72010-09-08 21:40:08 +0000706 // FIXME: Improve AST representation?
707 return move(Result);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000708}
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +0000709
John McCall6ec278d2011-01-27 09:37:56 +0000710/// doesUsualArrayDeleteWantSize - Answers whether the usual
711/// operator delete[] for the given type has a size_t parameter.
712static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
713 QualType allocType) {
714 const RecordType *record =
715 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
716 if (!record) return false;
717
718 // Try to find an operator delete[] in class scope.
719
720 DeclarationName deleteName =
721 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
722 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
723 S.LookupQualifiedName(ops, record->getDecl());
724
725 // We're just doing this for information.
726 ops.suppressDiagnostics();
727
728 // Very likely: there's no operator delete[].
729 if (ops.empty()) return false;
730
731 // If it's ambiguous, it should be illegal to call operator delete[]
732 // on this thing, so it doesn't matter if we allocate extra space or not.
733 if (ops.isAmbiguous()) return false;
734
735 LookupResult::Filter filter = ops.makeFilter();
736 while (filter.hasNext()) {
737 NamedDecl *del = filter.next()->getUnderlyingDecl();
738
739 // C++0x [basic.stc.dynamic.deallocation]p2:
740 // A template instance is never a usual deallocation function,
741 // regardless of its signature.
742 if (isa<FunctionTemplateDecl>(del)) {
743 filter.erase();
744 continue;
745 }
746
747 // C++0x [basic.stc.dynamic.deallocation]p2:
748 // If class T does not declare [an operator delete[] with one
749 // parameter] but does declare a member deallocation function
750 // named operator delete[] with exactly two parameters, the
751 // second of which has type std::size_t, then this function
752 // is a usual deallocation function.
753 if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) {
754 filter.erase();
755 continue;
756 }
757 }
758 filter.done();
759
760 if (!ops.isSingleResult()) return false;
761
762 const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl());
763 return (del->getNumParams() == 2);
764}
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +0000765
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000766/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
767/// @code new (memory) int[size][4] @endcode
768/// or
769/// @code ::new Foo(23, "hello") @endcode
770/// For the interpretation of this heap of arguments, consult the base version.
John McCall60d7b3a2010-08-24 06:29:42 +0000771ExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000772Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000773 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000774 SourceLocation PlacementRParen, SourceRange TypeIdParens,
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000775 Declarator &D, SourceLocation ConstructorLParen,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000776 MultiExprArg ConstructorArgs,
Mike Stump1eb44332009-09-09 15:08:12 +0000777 SourceLocation ConstructorRParen) {
Richard Smith34b41d92011-02-20 03:19:35 +0000778 bool TypeContainsAuto = D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
779
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000780 Expr *ArraySize = 0;
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000781 // If the specified type is an array, unwrap it and save the expression.
782 if (D.getNumTypeObjects() > 0 &&
783 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
784 DeclaratorChunk &Chunk = D.getTypeObject(0);
Richard Smith34b41d92011-02-20 03:19:35 +0000785 if (TypeContainsAuto)
786 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
787 << D.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000788 if (Chunk.Arr.hasStatic)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000789 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
790 << D.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000791 if (!Chunk.Arr.NumElts)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000792 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
793 << D.getSourceRange());
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000794
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000795 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000796 D.DropFirstTypeObject();
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000797 }
798
Douglas Gregor043cad22009-09-11 00:18:58 +0000799 // Every dimension shall be of constant size.
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000800 if (ArraySize) {
801 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
Douglas Gregor043cad22009-09-11 00:18:58 +0000802 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
803 break;
804
805 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
806 if (Expr *NumElts = (Expr *)Array.NumElts) {
807 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
808 !NumElts->isIntegerConstantExpr(Context)) {
809 Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst)
810 << NumElts->getSourceRange();
811 return ExprError();
812 }
813 }
814 }
815 }
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000816
Richard Smith34b41d92011-02-20 03:19:35 +0000817 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/0, /*OwnedDecl=*/0,
818 /*AllowAuto=*/true);
John McCallbf1a0282010-06-04 23:28:52 +0000819 QualType AllocType = TInfo->getType();
Chris Lattnereaaebc72009-04-25 08:06:05 +0000820 if (D.isInvalidType())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000821 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000822
Mike Stump1eb44332009-09-09 15:08:12 +0000823 return BuildCXXNew(StartLoc, UseGlobal,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000824 PlacementLParen,
Mike Stump1eb44332009-09-09 15:08:12 +0000825 move(PlacementArgs),
Douglas Gregor3433cf72009-05-21 00:00:09 +0000826 PlacementRParen,
Douglas Gregor4bd40312010-07-13 15:54:32 +0000827 TypeIdParens,
Mike Stump1eb44332009-09-09 15:08:12 +0000828 AllocType,
Douglas Gregor1bb2a932010-09-07 21:49:58 +0000829 TInfo,
John McCall9ae2f072010-08-23 23:25:46 +0000830 ArraySize,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000831 ConstructorLParen,
832 move(ConstructorArgs),
Richard Smith34b41d92011-02-20 03:19:35 +0000833 ConstructorRParen,
834 TypeContainsAuto);
Douglas Gregor3433cf72009-05-21 00:00:09 +0000835}
836
John McCall60d7b3a2010-08-24 06:29:42 +0000837ExprResult
Douglas Gregor3433cf72009-05-21 00:00:09 +0000838Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
839 SourceLocation PlacementLParen,
840 MultiExprArg PlacementArgs,
841 SourceLocation PlacementRParen,
Douglas Gregor4bd40312010-07-13 15:54:32 +0000842 SourceRange TypeIdParens,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000843 QualType AllocType,
Douglas Gregor1bb2a932010-09-07 21:49:58 +0000844 TypeSourceInfo *AllocTypeInfo,
John McCall9ae2f072010-08-23 23:25:46 +0000845 Expr *ArraySize,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000846 SourceLocation ConstructorLParen,
847 MultiExprArg ConstructorArgs,
Richard Smith34b41d92011-02-20 03:19:35 +0000848 SourceLocation ConstructorRParen,
849 bool TypeMayContainAuto) {
Douglas Gregor1bb2a932010-09-07 21:49:58 +0000850 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000851
Richard Smith34b41d92011-02-20 03:19:35 +0000852 // C++0x [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
853 if (TypeMayContainAuto && AllocType->getContainedAutoType()) {
854 if (ConstructorArgs.size() == 0)
855 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
856 << AllocType << TypeRange);
857 if (ConstructorArgs.size() != 1) {
858 Expr *FirstBad = ConstructorArgs.get()[1];
859 return ExprError(Diag(FirstBad->getSourceRange().getBegin(),
860 diag::err_auto_new_ctor_multiple_expressions)
861 << AllocType << TypeRange);
862 }
Richard Smitha085da82011-03-17 16:11:59 +0000863 TypeSourceInfo *DeducedType = 0;
864 if (!DeduceAutoType(AllocTypeInfo, ConstructorArgs.get()[0], DeducedType))
Richard Smith34b41d92011-02-20 03:19:35 +0000865 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
866 << AllocType
867 << ConstructorArgs.get()[0]->getType()
868 << TypeRange
869 << ConstructorArgs.get()[0]->getSourceRange());
Richard Smitha085da82011-03-17 16:11:59 +0000870 if (!DeducedType)
871 return ExprError();
Richard Smith34b41d92011-02-20 03:19:35 +0000872
Richard Smitha085da82011-03-17 16:11:59 +0000873 AllocTypeInfo = DeducedType;
874 AllocType = AllocTypeInfo->getType();
Richard Smith34b41d92011-02-20 03:19:35 +0000875 }
876
Douglas Gregor3caf04e2010-05-16 16:01:03 +0000877 // Per C++0x [expr.new]p5, the type being constructed may be a
878 // typedef of an array type.
John McCall9ae2f072010-08-23 23:25:46 +0000879 if (!ArraySize) {
Douglas Gregor3caf04e2010-05-16 16:01:03 +0000880 if (const ConstantArrayType *Array
881 = Context.getAsConstantArrayType(AllocType)) {
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +0000882 ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
883 Context.getSizeType(),
884 TypeRange.getEnd());
Douglas Gregor3caf04e2010-05-16 16:01:03 +0000885 AllocType = Array->getElementType();
886 }
887 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000888
Douglas Gregora0750762010-10-06 16:00:31 +0000889 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
890 return ExprError();
891
Douglas Gregor3caf04e2010-05-16 16:01:03 +0000892 QualType ResultType = Context.getPointerType(AllocType);
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000893
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000894 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
895 // or enumeration type with a non-negative value."
Sebastian Redl28507842009-02-26 14:39:58 +0000896 if (ArraySize && !ArraySize->isTypeDependent()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000897
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000898 QualType SizeType = ArraySize->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000899
John McCall60d7b3a2010-08-24 06:29:42 +0000900 ExprResult ConvertedSize
John McCall9ae2f072010-08-23 23:25:46 +0000901 = ConvertToIntegralOrEnumerationType(StartLoc, ArraySize,
Douglas Gregor6bc574d2010-06-30 00:20:43 +0000902 PDiag(diag::err_array_size_not_integral),
903 PDiag(diag::err_array_size_incomplete_type)
904 << ArraySize->getSourceRange(),
905 PDiag(diag::err_array_size_explicit_conversion),
906 PDiag(diag::note_array_size_conversion),
907 PDiag(diag::err_array_size_ambiguous_conversion),
908 PDiag(diag::note_array_size_conversion),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000909 PDiag(getLangOptions().CPlusPlus0x? 0
Douglas Gregor6bc574d2010-06-30 00:20:43 +0000910 : diag::ext_array_size_conversion));
911 if (ConvertedSize.isInvalid())
912 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000913
John McCall9ae2f072010-08-23 23:25:46 +0000914 ArraySize = ConvertedSize.take();
Douglas Gregor6bc574d2010-06-30 00:20:43 +0000915 SizeType = ArraySize->getType();
Douglas Gregor1274ccd2010-10-08 23:50:27 +0000916 if (!SizeType->isIntegralOrUnscopedEnumerationType())
Douglas Gregor6bc574d2010-06-30 00:20:43 +0000917 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000918
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000919 // Let's see if this is a constant < 0. If so, we reject it out of hand.
920 // We don't care about special rules, so we tell the machinery it's not
921 // evaluated - it gives us a result in more cases.
Sebastian Redl28507842009-02-26 14:39:58 +0000922 if (!ArraySize->isValueDependent()) {
923 llvm::APSInt Value;
924 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) {
925 if (Value < llvm::APSInt(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000926 llvm::APInt::getNullValue(Value.getBitWidth()),
Anders Carlssonac18b2e2009-09-23 00:37:25 +0000927 Value.isUnsigned()))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000928 return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
Douglas Gregor2767ce22010-08-18 00:39:00 +0000929 diag::err_typecheck_negative_array_size)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000930 << ArraySize->getSourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000931
Douglas Gregor2767ce22010-08-18 00:39:00 +0000932 if (!AllocType->isDependentType()) {
933 unsigned ActiveSizeBits
934 = ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
935 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000936 Diag(ArraySize->getSourceRange().getBegin(),
Douglas Gregor2767ce22010-08-18 00:39:00 +0000937 diag::err_array_too_large)
938 << Value.toString(10)
939 << ArraySize->getSourceRange();
940 return ExprError();
941 }
942 }
Douglas Gregor4bd40312010-07-13 15:54:32 +0000943 } else if (TypeIdParens.isValid()) {
944 // Can't have dynamic array size when the type-id is in parentheses.
945 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
946 << ArraySize->getSourceRange()
947 << FixItHint::CreateRemoval(TypeIdParens.getBegin())
948 << FixItHint::CreateRemoval(TypeIdParens.getEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000949
Douglas Gregor4bd40312010-07-13 15:54:32 +0000950 TypeIdParens = SourceRange();
Sebastian Redl28507842009-02-26 14:39:58 +0000951 }
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000952 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000953
John McCall7d166272011-05-15 07:14:44 +0000954 // Note that we do *not* convert the argument in any way. It can
955 // be signed, larger than size_t, whatever.
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000956 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000957
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000958 FunctionDecl *OperatorNew = 0;
959 FunctionDecl *OperatorDelete = 0;
Sebastian Redlf53597f2009-03-15 17:47:39 +0000960 Expr **PlaceArgs = (Expr**)PlacementArgs.get();
961 unsigned NumPlaceArgs = PlacementArgs.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000962
Sebastian Redl28507842009-02-26 14:39:58 +0000963 if (!AllocType->isDependentType() &&
964 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) &&
965 FindAllocationFunctions(StartLoc,
Sebastian Redl00e68e22009-02-09 18:24:27 +0000966 SourceRange(PlacementLParen, PlacementRParen),
967 UseGlobal, AllocType, ArraySize, PlaceArgs,
968 NumPlaceArgs, OperatorNew, OperatorDelete))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000969 return ExprError();
John McCall6ec278d2011-01-27 09:37:56 +0000970
971 // If this is an array allocation, compute whether the usual array
972 // deallocation function for the type has a size_t parameter.
973 bool UsualArrayDeleteWantsSize = false;
974 if (ArraySize && !AllocType->isDependentType())
975 UsualArrayDeleteWantsSize
976 = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
977
Fariborz Jahanian048f52a2009-11-24 18:29:37 +0000978 llvm::SmallVector<Expr *, 8> AllPlaceArgs;
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000979 if (OperatorNew) {
980 // Add default arguments, if any.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000981 const FunctionProtoType *Proto =
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000982 OperatorNew->getType()->getAs<FunctionProtoType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000983 VariadicCallType CallType =
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +0000984 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000985
Anders Carlsson28e94832010-05-03 02:07:56 +0000986 if (GatherArgumentsForCall(PlacementLParen, OperatorNew,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000987 Proto, 1, PlaceArgs, NumPlaceArgs,
Anders Carlsson28e94832010-05-03 02:07:56 +0000988 AllPlaceArgs, CallType))
Fariborz Jahanian048f52a2009-11-24 18:29:37 +0000989 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000990
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000991 NumPlaceArgs = AllPlaceArgs.size();
992 if (NumPlaceArgs > 0)
993 PlaceArgs = &AllPlaceArgs[0];
994 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000995
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000996 bool Init = ConstructorLParen.isValid();
997 // --- Choosing a constructor ---
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000998 CXXConstructorDecl *Constructor = 0;
Sebastian Redlf53597f2009-03-15 17:47:39 +0000999 Expr **ConsArgs = (Expr**)ConstructorArgs.get();
1000 unsigned NumConsArgs = ConstructorArgs.size();
John McCallca0408f2010-08-23 06:44:23 +00001001 ASTOwningVector<Expr*> ConvertedConstructorArgs(*this);
Eli Friedmana8ce9ec2009-11-08 22:15:39 +00001002
Anders Carlsson48c95012010-05-03 15:45:23 +00001003 // Array 'new' can't have any initializers.
Anders Carlsson55cbd6e2010-05-16 16:24:20 +00001004 if (NumConsArgs && (ResultType->isArrayType() || ArraySize)) {
Anders Carlsson48c95012010-05-03 15:45:23 +00001005 SourceRange InitRange(ConsArgs[0]->getLocStart(),
1006 ConsArgs[NumConsArgs - 1]->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001007
Anders Carlsson48c95012010-05-03 15:45:23 +00001008 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
1009 return ExprError();
1010 }
1011
Douglas Gregor99a2e602009-12-16 01:38:02 +00001012 if (!AllocType->isDependentType() &&
1013 !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) {
1014 // C++0x [expr.new]p15:
1015 // A new-expression that creates an object of type T initializes that
1016 // object as follows:
1017 InitializationKind Kind
1018 // - If the new-initializer is omitted, the object is default-
1019 // initialized (8.5); if no initialization is performed,
1020 // the object has indeterminate value
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001021 = !Init? InitializationKind::CreateDefault(TypeRange.getBegin())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001022 // - Otherwise, the new-initializer is interpreted according to the
Douglas Gregor99a2e602009-12-16 01:38:02 +00001023 // initialization rules of 8.5 for direct-initialization.
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001024 : InitializationKind::CreateDirect(TypeRange.getBegin(),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001025 ConstructorLParen,
Douglas Gregor99a2e602009-12-16 01:38:02 +00001026 ConstructorRParen);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001027
Douglas Gregor99a2e602009-12-16 01:38:02 +00001028 InitializedEntity Entity
Douglas Gregord6542d82009-12-22 15:35:07 +00001029 = InitializedEntity::InitializeNew(StartLoc, AllocType);
Douglas Gregor99a2e602009-12-16 01:38:02 +00001030 InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001031 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
Douglas Gregor99a2e602009-12-16 01:38:02 +00001032 move(ConstructorArgs));
1033 if (FullInit.isInvalid())
1034 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001035
1036 // FullInit is our initializer; walk through it to determine if it's a
Douglas Gregor99a2e602009-12-16 01:38:02 +00001037 // constructor call, which CXXNewExpr handles directly.
1038 if (Expr *FullInitExpr = (Expr *)FullInit.get()) {
1039 if (CXXBindTemporaryExpr *Binder
1040 = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr))
1041 FullInitExpr = Binder->getSubExpr();
1042 if (CXXConstructExpr *Construct
1043 = dyn_cast<CXXConstructExpr>(FullInitExpr)) {
1044 Constructor = Construct->getConstructor();
1045 for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(),
1046 AEnd = Construct->arg_end();
1047 A != AEnd; ++A)
John McCall3fa5cae2010-10-26 07:05:15 +00001048 ConvertedConstructorArgs.push_back(*A);
Douglas Gregor99a2e602009-12-16 01:38:02 +00001049 } else {
1050 // Take the converted initializer.
1051 ConvertedConstructorArgs.push_back(FullInit.release());
1052 }
1053 } else {
1054 // No initialization required.
1055 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001056
Douglas Gregor99a2e602009-12-16 01:38:02 +00001057 // Take the converted arguments and use them for the new expression.
Douglas Gregor39da0b82009-09-09 23:08:42 +00001058 NumConsArgs = ConvertedConstructorArgs.size();
1059 ConsArgs = (Expr **)ConvertedConstructorArgs.take();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001060 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001061
Douglas Gregor6d908702010-02-26 05:06:18 +00001062 // Mark the new and delete operators as referenced.
1063 if (OperatorNew)
1064 MarkDeclarationReferenced(StartLoc, OperatorNew);
1065 if (OperatorDelete)
1066 MarkDeclarationReferenced(StartLoc, OperatorDelete);
1067
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001068 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001069
Sebastian Redlf53597f2009-03-15 17:47:39 +00001070 PlacementArgs.release();
1071 ConstructorArgs.release();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001072
Ted Kremenekad7fe862010-02-11 22:51:03 +00001073 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew,
Douglas Gregor4bd40312010-07-13 15:54:32 +00001074 PlaceArgs, NumPlaceArgs, TypeIdParens,
Ted Kremenekad7fe862010-02-11 22:51:03 +00001075 ArraySize, Constructor, Init,
1076 ConsArgs, NumConsArgs, OperatorDelete,
John McCall6ec278d2011-01-27 09:37:56 +00001077 UsualArrayDeleteWantsSize,
Douglas Gregor1bb2a932010-09-07 21:49:58 +00001078 ResultType, AllocTypeInfo,
1079 StartLoc,
Ted Kremenekad7fe862010-02-11 22:51:03 +00001080 Init ? ConstructorRParen :
Chandler Carruth428edaf2010-10-25 08:47:36 +00001081 TypeRange.getEnd(),
1082 ConstructorLParen, ConstructorRParen));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001083}
1084
1085/// CheckAllocatedType - Checks that a type is suitable as the allocated type
1086/// in a new-expression.
1087/// dimension off and stores the size expression in ArraySize.
Douglas Gregor3433cf72009-05-21 00:00:09 +00001088bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +00001089 SourceRange R) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001090 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
1091 // abstract class type or array thereof.
Douglas Gregore7450f52009-03-24 19:52:54 +00001092 if (AllocType->isFunctionType())
Douglas Gregor3433cf72009-05-21 00:00:09 +00001093 return Diag(Loc, diag::err_bad_new_type)
1094 << AllocType << 0 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +00001095 else if (AllocType->isReferenceType())
Douglas Gregor3433cf72009-05-21 00:00:09 +00001096 return Diag(Loc, diag::err_bad_new_type)
1097 << AllocType << 1 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +00001098 else if (!AllocType->isDependentType() &&
Douglas Gregor3433cf72009-05-21 00:00:09 +00001099 RequireCompleteType(Loc, AllocType,
Anders Carlssonb7906612009-08-26 23:45:07 +00001100 PDiag(diag::err_new_incomplete_type)
1101 << R))
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001102 return true;
Douglas Gregor3433cf72009-05-21 00:00:09 +00001103 else if (RequireNonAbstractType(Loc, AllocType,
Douglas Gregore7450f52009-03-24 19:52:54 +00001104 diag::err_allocation_of_abstract_type))
1105 return true;
Douglas Gregora0750762010-10-06 16:00:31 +00001106 else if (AllocType->isVariablyModifiedType())
1107 return Diag(Loc, diag::err_variably_modified_new_type)
1108 << AllocType;
Douglas Gregor5666d362011-04-15 19:46:20 +00001109 else if (unsigned AddressSpace = AllocType.getAddressSpace())
1110 return Diag(Loc, diag::err_address_space_qualified_new)
1111 << AllocType.getUnqualifiedType() << AddressSpace;
1112
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001113 return false;
1114}
1115
Douglas Gregor6d908702010-02-26 05:06:18 +00001116/// \brief Determine whether the given function is a non-placement
1117/// deallocation function.
1118static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) {
1119 if (FD->isInvalidDecl())
1120 return false;
1121
1122 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1123 return Method->isUsualDeallocationFunction();
1124
1125 return ((FD->getOverloadedOperator() == OO_Delete ||
1126 FD->getOverloadedOperator() == OO_Array_Delete) &&
1127 FD->getNumParams() == 1);
1128}
1129
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001130/// FindAllocationFunctions - Finds the overloads of operator new and delete
1131/// that are appropriate for the allocation.
Sebastian Redl00e68e22009-02-09 18:24:27 +00001132bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1133 bool UseGlobal, QualType AllocType,
1134 bool IsArray, Expr **PlaceArgs,
1135 unsigned NumPlaceArgs,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001136 FunctionDecl *&OperatorNew,
Mike Stump1eb44332009-09-09 15:08:12 +00001137 FunctionDecl *&OperatorDelete) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001138 // --- Choosing an allocation function ---
1139 // C++ 5.3.4p8 - 14 & 18
1140 // 1) If UseGlobal is true, only look in the global scope. Else, also look
1141 // in the scope of the allocated class.
1142 // 2) If an array size is given, look for operator new[], else look for
1143 // operator new.
1144 // 3) The first argument is always size_t. Append the arguments from the
1145 // placement form.
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001146
1147 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
1148 // We don't care about the actual value of this argument.
1149 // FIXME: Should the Sema create the expression and embed it in the syntax
1150 // tree? Or should the consumer just recalculate the value?
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00001151 IntegerLiteral Size(Context, llvm::APInt::getNullValue(
Anders Carlssond67c4c32009-08-16 20:29:29 +00001152 Context.Target.getPointerWidth(0)),
1153 Context.getSizeType(),
1154 SourceLocation());
1155 AllocArgs[0] = &Size;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001156 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
1157
Douglas Gregor6d908702010-02-26 05:06:18 +00001158 // C++ [expr.new]p8:
1159 // If the allocated type is a non-array type, the allocation
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001160 // function's name is operator new and the deallocation function's
Douglas Gregor6d908702010-02-26 05:06:18 +00001161 // name is operator delete. If the allocated type is an array
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001162 // type, the allocation function's name is operator new[] and the
1163 // deallocation function's name is operator delete[].
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001164 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
1165 IsArray ? OO_Array_New : OO_New);
Douglas Gregor6d908702010-02-26 05:06:18 +00001166 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1167 IsArray ? OO_Array_Delete : OO_Delete);
1168
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001169 QualType AllocElemType = Context.getBaseElementType(AllocType);
1170
1171 if (AllocElemType->isRecordType() && !UseGlobal) {
Mike Stump1eb44332009-09-09 15:08:12 +00001172 CXXRecordDecl *Record
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001173 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Sebastian Redl00e68e22009-02-09 18:24:27 +00001174 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +00001175 AllocArgs.size(), Record, /*AllowMissing=*/true,
1176 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001177 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001178 }
1179 if (!OperatorNew) {
1180 // Didn't find a member overload. Look for a global one.
1181 DeclareGlobalNewDelete();
Sebastian Redl7f662392008-12-04 22:20:51 +00001182 DeclContext *TUDecl = Context.getTranslationUnitDecl();
Sebastian Redl00e68e22009-02-09 18:24:27 +00001183 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +00001184 AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
1185 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001186 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001187 }
1188
John McCall9c82afc2010-04-20 02:18:25 +00001189 // We don't need an operator delete if we're running under
1190 // -fno-exceptions.
1191 if (!getLangOptions().Exceptions) {
1192 OperatorDelete = 0;
1193 return false;
1194 }
1195
Anders Carlssond9583892009-05-31 20:26:12 +00001196 // FindAllocationOverload can change the passed in arguments, so we need to
1197 // copy them back.
1198 if (NumPlaceArgs > 0)
1199 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00001200
Douglas Gregor6d908702010-02-26 05:06:18 +00001201 // C++ [expr.new]p19:
1202 //
1203 // If the new-expression begins with a unary :: operator, the
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001204 // deallocation function's name is looked up in the global
Douglas Gregor6d908702010-02-26 05:06:18 +00001205 // scope. Otherwise, if the allocated type is a class type T or an
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001206 // array thereof, the deallocation function's name is looked up in
Douglas Gregor6d908702010-02-26 05:06:18 +00001207 // the scope of T. If this lookup fails to find the name, or if
1208 // the allocated type is not a class type or array thereof, the
NAKAMURA Takumi00995302011-01-27 07:09:49 +00001209 // deallocation function's name is looked up in the global scope.
Douglas Gregor6d908702010-02-26 05:06:18 +00001210 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001211 if (AllocElemType->isRecordType() && !UseGlobal) {
Douglas Gregor6d908702010-02-26 05:06:18 +00001212 CXXRecordDecl *RD
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001213 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
Douglas Gregor6d908702010-02-26 05:06:18 +00001214 LookupQualifiedName(FoundDelete, RD);
1215 }
John McCall90c8c572010-03-18 08:19:33 +00001216 if (FoundDelete.isAmbiguous())
1217 return true; // FIXME: clean up expressions?
Douglas Gregor6d908702010-02-26 05:06:18 +00001218
1219 if (FoundDelete.empty()) {
1220 DeclareGlobalNewDelete();
1221 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
1222 }
1223
1224 FoundDelete.suppressDiagnostics();
John McCall9aa472c2010-03-19 07:35:19 +00001225
1226 llvm::SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
1227
John McCalledeb6c92010-09-14 21:34:24 +00001228 // Whether we're looking for a placement operator delete is dictated
1229 // by whether we selected a placement operator new, not by whether
1230 // we had explicit placement arguments. This matters for things like
1231 // struct A { void *operator new(size_t, int = 0); ... };
1232 // A *a = new A()
1233 bool isPlacementNew = (NumPlaceArgs > 0 || OperatorNew->param_size() != 1);
1234
1235 if (isPlacementNew) {
Douglas Gregor6d908702010-02-26 05:06:18 +00001236 // C++ [expr.new]p20:
1237 // A declaration of a placement deallocation function matches the
1238 // declaration of a placement allocation function if it has the
1239 // same number of parameters and, after parameter transformations
1240 // (8.3.5), all parameter types except the first are
1241 // identical. [...]
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001242 //
Douglas Gregor6d908702010-02-26 05:06:18 +00001243 // To perform this comparison, we compute the function type that
1244 // the deallocation function should have, and use that type both
1245 // for template argument deduction and for comparison purposes.
John McCalle23cf432010-12-14 08:05:40 +00001246 //
1247 // FIXME: this comparison should ignore CC and the like.
Douglas Gregor6d908702010-02-26 05:06:18 +00001248 QualType ExpectedFunctionType;
1249 {
1250 const FunctionProtoType *Proto
1251 = OperatorNew->getType()->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00001252
Douglas Gregor6d908702010-02-26 05:06:18 +00001253 llvm::SmallVector<QualType, 4> ArgTypes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001254 ArgTypes.push_back(Context.VoidPtrTy);
Douglas Gregor6d908702010-02-26 05:06:18 +00001255 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I)
1256 ArgTypes.push_back(Proto->getArgType(I));
1257
John McCalle23cf432010-12-14 08:05:40 +00001258 FunctionProtoType::ExtProtoInfo EPI;
1259 EPI.Variadic = Proto->isVariadic();
1260
Douglas Gregor6d908702010-02-26 05:06:18 +00001261 ExpectedFunctionType
1262 = Context.getFunctionType(Context.VoidTy, ArgTypes.data(),
John McCalle23cf432010-12-14 08:05:40 +00001263 ArgTypes.size(), EPI);
Douglas Gregor6d908702010-02-26 05:06:18 +00001264 }
1265
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001266 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001267 DEnd = FoundDelete.end();
1268 D != DEnd; ++D) {
1269 FunctionDecl *Fn = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001270 if (FunctionTemplateDecl *FnTmpl
Douglas Gregor6d908702010-02-26 05:06:18 +00001271 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
1272 // Perform template argument deduction to try to match the
1273 // expected function type.
1274 TemplateDeductionInfo Info(Context, StartLoc);
1275 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info))
1276 continue;
1277 } else
1278 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
1279
1280 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
John McCall9aa472c2010-03-19 07:35:19 +00001281 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +00001282 }
1283 } else {
1284 // C++ [expr.new]p20:
1285 // [...] Any non-placement deallocation function matches a
1286 // non-placement allocation function. [...]
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001287 for (LookupResult::iterator D = FoundDelete.begin(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001288 DEnd = FoundDelete.end();
1289 D != DEnd; ++D) {
1290 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
1291 if (isNonPlacementDeallocationFunction(Fn))
John McCall9aa472c2010-03-19 07:35:19 +00001292 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +00001293 }
1294 }
1295
1296 // C++ [expr.new]p20:
1297 // [...] If the lookup finds a single matching deallocation
1298 // function, that function will be called; otherwise, no
1299 // deallocation function will be called.
1300 if (Matches.size() == 1) {
John McCall9aa472c2010-03-19 07:35:19 +00001301 OperatorDelete = Matches[0].second;
Douglas Gregor6d908702010-02-26 05:06:18 +00001302
1303 // C++0x [expr.new]p20:
1304 // If the lookup finds the two-parameter form of a usual
1305 // deallocation function (3.7.4.2) and that function, considered
1306 // as a placement deallocation function, would have been
1307 // selected as a match for the allocation function, the program
1308 // is ill-formed.
1309 if (NumPlaceArgs && getLangOptions().CPlusPlus0x &&
1310 isNonPlacementDeallocationFunction(OperatorDelete)) {
1311 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001312 << SourceRange(PlaceArgs[0]->getLocStart(),
Douglas Gregor6d908702010-02-26 05:06:18 +00001313 PlaceArgs[NumPlaceArgs - 1]->getLocEnd());
1314 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1315 << DeleteName;
John McCall90c8c572010-03-18 08:19:33 +00001316 } else {
1317 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
John McCall9aa472c2010-03-19 07:35:19 +00001318 Matches[0].first);
Douglas Gregor6d908702010-02-26 05:06:18 +00001319 }
1320 }
1321
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001322 return false;
1323}
1324
Sebastian Redl7f662392008-12-04 22:20:51 +00001325/// FindAllocationOverload - Find an fitting overload for the allocation
1326/// function in the specified scope.
Sebastian Redl00e68e22009-02-09 18:24:27 +00001327bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1328 DeclarationName Name, Expr** Args,
1329 unsigned NumArgs, DeclContext *Ctx,
Sean Hunt2be7e902011-05-12 22:46:29 +00001330 bool AllowMissing, FunctionDecl *&Operator,
1331 bool Diagnose) {
John McCalla24dc2e2009-11-17 02:14:36 +00001332 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1333 LookupQualifiedName(R, Ctx);
John McCallf36e02d2009-10-09 21:13:30 +00001334 if (R.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001335 if (AllowMissing || !Diagnose)
Sebastian Redl7f662392008-12-04 22:20:51 +00001336 return false;
Sebastian Redl7f662392008-12-04 22:20:51 +00001337 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
Chris Lattner4330d652009-02-17 07:29:20 +00001338 << Name << Range;
Sebastian Redl7f662392008-12-04 22:20:51 +00001339 }
1340
John McCall90c8c572010-03-18 08:19:33 +00001341 if (R.isAmbiguous())
1342 return true;
1343
1344 R.suppressDiagnostics();
John McCallf36e02d2009-10-09 21:13:30 +00001345
John McCall5769d612010-02-08 23:07:23 +00001346 OverloadCandidateSet Candidates(StartLoc);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001347 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
Douglas Gregor5d64e5b2009-09-30 00:03:47 +00001348 Alloc != AllocEnd; ++Alloc) {
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001349 // Even member operator new/delete are implicitly treated as
1350 // static, so don't use AddMemberCandidate.
John McCall9aa472c2010-03-19 07:35:19 +00001351 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001352
John McCall9aa472c2010-03-19 07:35:19 +00001353 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1354 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001355 /*ExplicitTemplateArgs=*/0, Args, NumArgs,
1356 Candidates,
1357 /*SuppressUserConversions=*/false);
Douglas Gregor90916562009-09-29 18:16:17 +00001358 continue;
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001359 }
1360
John McCall9aa472c2010-03-19 07:35:19 +00001361 FunctionDecl *Fn = cast<FunctionDecl>(D);
1362 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates,
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001363 /*SuppressUserConversions=*/false);
Sebastian Redl7f662392008-12-04 22:20:51 +00001364 }
1365
1366 // Do the resolution.
1367 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00001368 switch (Candidates.BestViableFunction(*this, StartLoc, Best)) {
Sebastian Redl7f662392008-12-04 22:20:51 +00001369 case OR_Success: {
1370 // Got one!
1371 FunctionDecl *FnDecl = Best->Function;
Chandler Carruth25ca4212011-02-25 19:41:05 +00001372 MarkDeclarationReferenced(StartLoc, FnDecl);
Sebastian Redl7f662392008-12-04 22:20:51 +00001373 // The first argument is size_t, and the first parameter must be size_t,
1374 // too. This is checked on declaration and can be assumed. (It can't be
1375 // asserted on, though, since invalid decls are left in there.)
John McCall90c8c572010-03-18 08:19:33 +00001376 // Watch out for variadic allocator function.
Fariborz Jahanian048f52a2009-11-24 18:29:37 +00001377 unsigned NumArgsInFnDecl = FnDecl->getNumParams();
1378 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001379 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
1380 FnDecl->getParamDecl(i));
1381
1382 if (!Diagnose && !CanPerformCopyInitialization(Entity, Owned(Args[i])))
1383 return true;
1384
John McCall60d7b3a2010-08-24 06:29:42 +00001385 ExprResult Result
Sean Hunt2be7e902011-05-12 22:46:29 +00001386 = PerformCopyInitialization(Entity, SourceLocation(), Owned(Args[i]));
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001387 if (Result.isInvalid())
Sebastian Redl7f662392008-12-04 22:20:51 +00001388 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001389
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001390 Args[i] = Result.takeAs<Expr>();
Sebastian Redl7f662392008-12-04 22:20:51 +00001391 }
1392 Operator = FnDecl;
Sean Hunt2be7e902011-05-12 22:46:29 +00001393 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl,
1394 Diagnose);
Sebastian Redl7f662392008-12-04 22:20:51 +00001395 return false;
1396 }
1397
1398 case OR_No_Viable_Function:
Sean Hunt2be7e902011-05-12 22:46:29 +00001399 if (Diagnose)
1400 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
1401 << Name << Range;
John McCall120d63c2010-08-24 20:38:10 +00001402 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs);
Sebastian Redl7f662392008-12-04 22:20:51 +00001403 return true;
1404
1405 case OR_Ambiguous:
Sean Hunt2be7e902011-05-12 22:46:29 +00001406 if (Diagnose)
1407 Diag(StartLoc, diag::err_ovl_ambiguous_call)
1408 << Name << Range;
John McCall120d63c2010-08-24 20:38:10 +00001409 Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args, NumArgs);
Sebastian Redl7f662392008-12-04 22:20:51 +00001410 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001411
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001412 case OR_Deleted: {
Sean Hunt2be7e902011-05-12 22:46:29 +00001413 if (Diagnose)
1414 Diag(StartLoc, diag::err_ovl_deleted_call)
1415 << Best->Function->isDeleted()
1416 << Name
1417 << getDeletedOrUnavailableSuffix(Best->Function)
1418 << Range;
John McCall120d63c2010-08-24 20:38:10 +00001419 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001420 return true;
Sebastian Redl7f662392008-12-04 22:20:51 +00001421 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001422 }
Sebastian Redl7f662392008-12-04 22:20:51 +00001423 assert(false && "Unreachable, bad result from BestViableFunction");
1424 return true;
1425}
1426
1427
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001428/// DeclareGlobalNewDelete - Declare the global forms of operator new and
1429/// delete. These are:
1430/// @code
Sebastian Redl8999fe12011-03-14 18:08:30 +00001431/// // C++03:
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001432/// void* operator new(std::size_t) throw(std::bad_alloc);
1433/// void* operator new[](std::size_t) throw(std::bad_alloc);
1434/// void operator delete(void *) throw();
1435/// void operator delete[](void *) throw();
Sebastian Redl8999fe12011-03-14 18:08:30 +00001436/// // C++0x:
1437/// void* operator new(std::size_t);
1438/// void* operator new[](std::size_t);
1439/// void operator delete(void *);
1440/// void operator delete[](void *);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001441/// @endcode
Sebastian Redl8999fe12011-03-14 18:08:30 +00001442/// C++0x operator delete is implicitly noexcept.
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001443/// Note that the placement and nothrow forms of new are *not* implicitly
1444/// declared. Their use requires including \<new\>.
Mike Stump1eb44332009-09-09 15:08:12 +00001445void Sema::DeclareGlobalNewDelete() {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001446 if (GlobalNewDeleteDeclared)
1447 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001448
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001449 // C++ [basic.std.dynamic]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001450 // [...] The following allocation and deallocation functions (18.4) are
1451 // implicitly declared in global scope in each translation unit of a
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001452 // program
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001453 //
Sebastian Redl8999fe12011-03-14 18:08:30 +00001454 // C++03:
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001455 // void* operator new(std::size_t) throw(std::bad_alloc);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001456 // void* operator new[](std::size_t) throw(std::bad_alloc);
1457 // void operator delete(void*) throw();
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001458 // void operator delete[](void*) throw();
Sebastian Redl8999fe12011-03-14 18:08:30 +00001459 // C++0x:
1460 // void* operator new(std::size_t);
1461 // void* operator new[](std::size_t);
1462 // void operator delete(void*);
1463 // void operator delete[](void*);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001464 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001465 // These implicit declarations introduce only the function names operator
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001466 // new, operator new[], operator delete, operator delete[].
1467 //
1468 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
1469 // "std" or "bad_alloc" as necessary to form the exception specification.
1470 // However, we do not make these implicit declarations visible to name
1471 // lookup.
Sebastian Redl8999fe12011-03-14 18:08:30 +00001472 // Note that the C++0x versions of operator delete are deallocation functions,
1473 // and thus are implicitly noexcept.
1474 if (!StdBadAlloc && !getLangOptions().CPlusPlus0x) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001475 // The "std::bad_alloc" class has not yet been declared, so build it
1476 // implicitly.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001477 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
1478 getOrCreateStdNamespace(),
Abramo Bagnaraba877ad2011-03-09 14:09:51 +00001479 SourceLocation(), SourceLocation(),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001480 &PP.getIdentifierTable().get("bad_alloc"),
Abramo Bagnaraba877ad2011-03-09 14:09:51 +00001481 0);
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00001482 getStdBadAlloc()->setImplicit(true);
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001483 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001484
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001485 GlobalNewDeleteDeclared = true;
1486
1487 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
1488 QualType SizeT = Context.getSizeType();
Nuno Lopesfc284482009-12-16 16:59:22 +00001489 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001490
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001491 DeclareGlobalAllocationFunction(
1492 Context.DeclarationNames.getCXXOperatorName(OO_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001493 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001494 DeclareGlobalAllocationFunction(
1495 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001496 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001497 DeclareGlobalAllocationFunction(
1498 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
1499 Context.VoidTy, VoidPtr);
1500 DeclareGlobalAllocationFunction(
1501 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
1502 Context.VoidTy, VoidPtr);
1503}
1504
1505/// DeclareGlobalAllocationFunction - Declares a single implicit global
1506/// allocation function if it doesn't already exist.
1507void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
Nuno Lopesfc284482009-12-16 16:59:22 +00001508 QualType Return, QualType Argument,
1509 bool AddMallocAttr) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001510 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
1511
1512 // Check if this function is already declared.
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001513 {
Douglas Gregor5cc37092008-12-23 22:05:29 +00001514 DeclContext::lookup_iterator Alloc, AllocEnd;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001515 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name);
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001516 Alloc != AllocEnd; ++Alloc) {
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001517 // Only look at non-template functions, as it is the predefined,
1518 // non-templated allocation function we are trying to declare here.
1519 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
1520 QualType InitialParamType =
Douglas Gregor6e790ab2009-12-22 23:42:49 +00001521 Context.getCanonicalType(
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001522 Func->getParamDecl(0)->getType().getUnqualifiedType());
1523 // FIXME: Do we need to check for default arguments here?
Douglas Gregor7b868622010-08-18 15:06:25 +00001524 if (Func->getNumParams() == 1 && InitialParamType == Argument) {
1525 if(AddMallocAttr && !Func->hasAttr<MallocAttr>())
Sean Huntcf807c42010-08-18 23:23:40 +00001526 Func->addAttr(::new (Context) MallocAttr(SourceLocation(), Context));
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001527 return;
Douglas Gregor7b868622010-08-18 15:06:25 +00001528 }
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001529 }
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001530 }
1531 }
1532
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001533 QualType BadAllocType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001534 bool HasBadAllocExceptionSpec
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001535 = (Name.getCXXOverloadedOperator() == OO_New ||
1536 Name.getCXXOverloadedOperator() == OO_Array_New);
Sebastian Redl8999fe12011-03-14 18:08:30 +00001537 if (HasBadAllocExceptionSpec && !getLangOptions().CPlusPlus0x) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001538 assert(StdBadAlloc && "Must have std::bad_alloc declared");
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00001539 BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001540 }
John McCalle23cf432010-12-14 08:05:40 +00001541
1542 FunctionProtoType::ExtProtoInfo EPI;
John McCalle23cf432010-12-14 08:05:40 +00001543 if (HasBadAllocExceptionSpec) {
Sebastian Redl8999fe12011-03-14 18:08:30 +00001544 if (!getLangOptions().CPlusPlus0x) {
1545 EPI.ExceptionSpecType = EST_Dynamic;
1546 EPI.NumExceptions = 1;
1547 EPI.Exceptions = &BadAllocType;
1548 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00001549 } else {
Sebastian Redl8999fe12011-03-14 18:08:30 +00001550 EPI.ExceptionSpecType = getLangOptions().CPlusPlus0x ?
1551 EST_BasicNoexcept : EST_DynamicNone;
John McCalle23cf432010-12-14 08:05:40 +00001552 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001553
John McCalle23cf432010-12-14 08:05:40 +00001554 QualType FnType = Context.getFunctionType(Return, &Argument, 1, EPI);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001555 FunctionDecl *Alloc =
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001556 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(),
1557 SourceLocation(), Name,
John McCalld931b082010-08-26 03:08:43 +00001558 FnType, /*TInfo=*/0, SC_None,
1559 SC_None, false, true);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001560 Alloc->setImplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001561
Nuno Lopesfc284482009-12-16 16:59:22 +00001562 if (AddMallocAttr)
Sean Huntcf807c42010-08-18 23:23:40 +00001563 Alloc->addAttr(::new (Context) MallocAttr(SourceLocation(), Context));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001564
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001565 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001566 SourceLocation(), 0,
1567 Argument, /*TInfo=*/0,
1568 SC_None, SC_None, 0);
Douglas Gregor838db382010-02-11 01:19:42 +00001569 Alloc->setParams(&Param, 1);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001570
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001571 // FIXME: Also add this declaration to the IdentifierResolver, but
1572 // make sure it is at the end of the chain to coincide with the
1573 // global scope.
John McCall5f1e0942010-08-24 08:50:51 +00001574 Context.getTranslationUnitDecl()->addDecl(Alloc);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001575}
1576
Anders Carlsson78f74552009-11-15 18:45:20 +00001577bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
1578 DeclarationName Name,
Sean Hunt2be7e902011-05-12 22:46:29 +00001579 FunctionDecl* &Operator, bool Diagnose) {
John McCalla24dc2e2009-11-17 02:14:36 +00001580 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
Anders Carlsson78f74552009-11-15 18:45:20 +00001581 // Try to find operator delete/operator delete[] in class scope.
John McCalla24dc2e2009-11-17 02:14:36 +00001582 LookupQualifiedName(Found, RD);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001583
John McCalla24dc2e2009-11-17 02:14:36 +00001584 if (Found.isAmbiguous())
Anders Carlsson78f74552009-11-15 18:45:20 +00001585 return true;
Anders Carlsson78f74552009-11-15 18:45:20 +00001586
Chandler Carruth23893242010-06-28 00:30:51 +00001587 Found.suppressDiagnostics();
1588
John McCall046a7462010-08-04 00:31:26 +00001589 llvm::SmallVector<DeclAccessPair,4> Matches;
Anders Carlsson78f74552009-11-15 18:45:20 +00001590 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1591 F != FEnd; ++F) {
Chandler Carruth09556fd2010-08-08 07:04:00 +00001592 NamedDecl *ND = (*F)->getUnderlyingDecl();
1593
1594 // Ignore template operator delete members from the check for a usual
1595 // deallocation function.
1596 if (isa<FunctionTemplateDecl>(ND))
1597 continue;
1598
1599 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction())
John McCall046a7462010-08-04 00:31:26 +00001600 Matches.push_back(F.getPair());
1601 }
1602
1603 // There's exactly one suitable operator; pick it.
1604 if (Matches.size() == 1) {
1605 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
Sean Hunt2be7e902011-05-12 22:46:29 +00001606
1607 if (Operator->isDeleted()) {
1608 if (Diagnose) {
1609 Diag(StartLoc, diag::err_deleted_function_use);
1610 Diag(Operator->getLocation(), diag::note_unavailable_here) << true;
1611 }
1612 return true;
1613 }
1614
John McCall046a7462010-08-04 00:31:26 +00001615 CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
Sean Hunt2be7e902011-05-12 22:46:29 +00001616 Matches[0], Diagnose);
John McCall046a7462010-08-04 00:31:26 +00001617 return false;
1618
1619 // We found multiple suitable operators; complain about the ambiguity.
1620 } else if (!Matches.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001621 if (Diagnose) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00001622 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
1623 << Name << RD;
John McCall046a7462010-08-04 00:31:26 +00001624
Sean Huntcb45a0f2011-05-12 22:46:25 +00001625 for (llvm::SmallVectorImpl<DeclAccessPair>::iterator
1626 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F)
1627 Diag((*F)->getUnderlyingDecl()->getLocation(),
1628 diag::note_member_declared_here) << Name;
1629 }
John McCall046a7462010-08-04 00:31:26 +00001630 return true;
Anders Carlsson78f74552009-11-15 18:45:20 +00001631 }
1632
1633 // We did find operator delete/operator delete[] declarations, but
1634 // none of them were suitable.
1635 if (!Found.empty()) {
Sean Hunt2be7e902011-05-12 22:46:29 +00001636 if (Diagnose) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00001637 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
1638 << Name << RD;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001639
Sean Huntcb45a0f2011-05-12 22:46:25 +00001640 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1641 F != FEnd; ++F)
1642 Diag((*F)->getUnderlyingDecl()->getLocation(),
1643 diag::note_member_declared_here) << Name;
1644 }
Anders Carlsson78f74552009-11-15 18:45:20 +00001645 return true;
1646 }
1647
1648 // Look for a global declaration.
1649 DeclareGlobalNewDelete();
1650 DeclContext *TUDecl = Context.getTranslationUnitDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001651
Anders Carlsson78f74552009-11-15 18:45:20 +00001652 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation());
1653 Expr* DeallocArgs[1];
1654 DeallocArgs[0] = &Null;
1655 if (FindAllocationOverload(StartLoc, SourceRange(), Name,
Sean Hunt2be7e902011-05-12 22:46:29 +00001656 DeallocArgs, 1, TUDecl, !Diagnose,
1657 Operator, Diagnose))
Anders Carlsson78f74552009-11-15 18:45:20 +00001658 return true;
1659
1660 assert(Operator && "Did not find a deallocation function!");
1661 return false;
1662}
1663
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001664/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
1665/// @code ::delete ptr; @endcode
1666/// or
1667/// @code delete [] ptr; @endcode
John McCall60d7b3a2010-08-24 06:29:42 +00001668ExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001669Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
John Wiegley429bb272011-04-08 18:41:53 +00001670 bool ArrayForm, Expr *ExE) {
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001671 // C++ [expr.delete]p1:
1672 // The operand shall have a pointer type, or a class type having a single
1673 // conversion function to a pointer type. The result has type void.
1674 //
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001675 // DR599 amends "pointer type" to "pointer to object type" in both cases.
1676
John Wiegley429bb272011-04-08 18:41:53 +00001677 ExprResult Ex = Owned(ExE);
Anders Carlssond67c4c32009-08-16 20:29:29 +00001678 FunctionDecl *OperatorDelete = 0;
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00001679 bool ArrayFormAsWritten = ArrayForm;
John McCall6ec278d2011-01-27 09:37:56 +00001680 bool UsualArrayDeleteWantsSize = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001681
John Wiegley429bb272011-04-08 18:41:53 +00001682 if (!Ex.get()->isTypeDependent()) {
1683 QualType Type = Ex.get()->getType();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001684
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001685 if (const RecordType *Record = Type->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001686 if (RequireCompleteType(StartLoc, Type,
Douglas Gregor254a9422010-07-29 14:44:35 +00001687 PDiag(diag::err_delete_incomplete_class_type)))
1688 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001689
John McCall32daa422010-03-31 01:36:47 +00001690 llvm::SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions;
1691
Fariborz Jahanian53462782009-09-11 21:44:33 +00001692 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001693 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions();
John McCalleec51cf2010-01-20 00:46:10 +00001694 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCallba135432009-11-21 08:51:07 +00001695 E = Conversions->end(); I != E; ++I) {
John McCall32daa422010-03-31 01:36:47 +00001696 NamedDecl *D = I.getDecl();
1697 if (isa<UsingShadowDecl>(D))
1698 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1699
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001700 // Skip over templated conversion functions; they aren't considered.
John McCall32daa422010-03-31 01:36:47 +00001701 if (isa<FunctionTemplateDecl>(D))
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001702 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001703
John McCall32daa422010-03-31 01:36:47 +00001704 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001705
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001706 QualType ConvType = Conv->getConversionType().getNonReferenceType();
1707 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
Eli Friedman13578692010-08-05 02:49:48 +00001708 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001709 ObjectPtrConversions.push_back(Conv);
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001710 }
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001711 if (ObjectPtrConversions.size() == 1) {
1712 // We have a single conversion to a pointer-to-object type. Perform
1713 // that conversion.
John McCall32daa422010-03-31 01:36:47 +00001714 // TODO: don't redo the conversion calculation.
John Wiegley429bb272011-04-08 18:41:53 +00001715 ExprResult Res =
1716 PerformImplicitConversion(Ex.get(),
John McCall32daa422010-03-31 01:36:47 +00001717 ObjectPtrConversions.front()->getConversionType(),
John Wiegley429bb272011-04-08 18:41:53 +00001718 AA_Converting);
1719 if (Res.isUsable()) {
1720 Ex = move(Res);
1721 Type = Ex.get()->getType();
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001722 }
1723 }
1724 else if (ObjectPtrConversions.size() > 1) {
1725 Diag(StartLoc, diag::err_ambiguous_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00001726 << Type << Ex.get()->getSourceRange();
John McCall32daa422010-03-31 01:36:47 +00001727 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++)
1728 NoteOverloadCandidate(ObjectPtrConversions[i]);
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001729 return ExprError();
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001730 }
Sebastian Redl28507842009-02-26 14:39:58 +00001731 }
1732
Sebastian Redlf53597f2009-03-15 17:47:39 +00001733 if (!Type->isPointerType())
1734 return ExprError(Diag(StartLoc, diag::err_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00001735 << Type << Ex.get()->getSourceRange());
Sebastian Redl28507842009-02-26 14:39:58 +00001736
Ted Kremenek6217b802009-07-29 21:53:49 +00001737 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
Douglas Gregor94a61572010-05-24 17:01:56 +00001738 if (Pointee->isVoidType() && !isSFINAEContext()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001739 // The C++ standard bans deleting a pointer to a non-object type, which
Douglas Gregor94a61572010-05-24 17:01:56 +00001740 // effectively bans deletion of "void*". However, most compilers support
1741 // this, so we treat it as a warning unless we're in a SFINAE context.
1742 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
John Wiegley429bb272011-04-08 18:41:53 +00001743 << Type << Ex.get()->getSourceRange();
Douglas Gregor94a61572010-05-24 17:01:56 +00001744 } else if (Pointee->isFunctionType() || Pointee->isVoidType())
Sebastian Redlf53597f2009-03-15 17:47:39 +00001745 return ExprError(Diag(StartLoc, diag::err_delete_operand)
John Wiegley429bb272011-04-08 18:41:53 +00001746 << Type << Ex.get()->getSourceRange());
Douglas Gregor8dcb29d2009-03-24 20:13:58 +00001747 else if (!Pointee->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00001748 RequireCompleteType(StartLoc, Pointee,
Anders Carlssonb7906612009-08-26 23:45:07 +00001749 PDiag(diag::warn_delete_incomplete)
John Wiegley429bb272011-04-08 18:41:53 +00001750 << Ex.get()->getSourceRange()))
Douglas Gregor8dcb29d2009-03-24 20:13:58 +00001751 return ExprError();
Douglas Gregor5666d362011-04-15 19:46:20 +00001752 else if (unsigned AddressSpace = Pointee.getAddressSpace())
1753 return Diag(Ex.get()->getLocStart(),
1754 diag::err_address_space_qualified_delete)
1755 << Pointee.getUnqualifiedType() << AddressSpace;
Douglas Gregor1070c9f2009-09-29 21:38:53 +00001756 // C++ [expr.delete]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001757 // [Note: a pointer to a const type can be the operand of a
1758 // delete-expression; it is not necessary to cast away the constness
1759 // (5.2.11) of the pointer expression before it is used as the operand
Douglas Gregor1070c9f2009-09-29 21:38:53 +00001760 // of the delete-expression. ]
John Wiegley429bb272011-04-08 18:41:53 +00001761 Ex = ImpCastExprToType(Ex.take(), Context.getPointerType(Context.VoidTy),
John McCall2de56d12010-08-25 11:45:40 +00001762 CK_NoOp);
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00001763
1764 if (Pointee->isArrayType() && !ArrayForm) {
1765 Diag(StartLoc, diag::warn_delete_array_type)
John Wiegley429bb272011-04-08 18:41:53 +00001766 << Type << Ex.get()->getSourceRange()
Argyrios Kyrtzidis4076dac2010-09-13 20:15:54 +00001767 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(StartLoc), "[]");
1768 ArrayForm = true;
1769 }
1770
Anders Carlssond67c4c32009-08-16 20:29:29 +00001771 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1772 ArrayForm ? OO_Array_Delete : OO_Delete);
1773
Argyrios Kyrtzidisd2932982010-08-25 23:14:56 +00001774 QualType PointeeElem = Context.getBaseElementType(Pointee);
1775 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) {
Anders Carlsson78f74552009-11-15 18:45:20 +00001776 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1777
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001778 if (!UseGlobal &&
Anders Carlsson78f74552009-11-15 18:45:20 +00001779 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete))
Anders Carlsson0ba63ea2009-11-14 03:17:38 +00001780 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001781
John McCall6ec278d2011-01-27 09:37:56 +00001782 // If we're allocating an array of records, check whether the
1783 // usual operator delete[] has a size_t parameter.
1784 if (ArrayForm) {
1785 // If the user specifically asked to use the global allocator,
1786 // we'll need to do the lookup into the class.
1787 if (UseGlobal)
1788 UsualArrayDeleteWantsSize =
1789 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
1790
1791 // Otherwise, the usual operator delete[] should be the
1792 // function we just found.
1793 else if (isa<CXXMethodDecl>(OperatorDelete))
1794 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2);
1795 }
1796
Anders Carlsson78f74552009-11-15 18:45:20 +00001797 if (!RD->hasTrivialDestructor())
Douglas Gregor9b623632010-10-12 23:32:35 +00001798 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001799 MarkDeclarationReferenced(StartLoc,
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001800 const_cast<CXXDestructorDecl*>(Dtor));
Douglas Gregor9b623632010-10-12 23:32:35 +00001801 DiagnoseUseOfDecl(Dtor, StartLoc);
1802 }
Argyrios Kyrtzidis6f0074a2011-05-24 19:53:26 +00001803
1804 // C++ [expr.delete]p3:
1805 // In the first alternative (delete object), if the static type of the
1806 // object to be deleted is different from its dynamic type, the static
1807 // type shall be a base class of the dynamic type of the object to be
1808 // deleted and the static type shall have a virtual destructor or the
1809 // behavior is undefined.
1810 //
1811 // Note: a final class cannot be derived from, no issue there
1812 if (!ArrayForm && RD->isPolymorphic() && !RD->hasAttr<FinalAttr>()) {
1813 CXXDestructorDecl *dtor = RD->getDestructor();
1814 if (!dtor || !dtor->isVirtual())
1815 Diag(StartLoc, diag::warn_delete_non_virtual_dtor) << PointeeElem;
1816 }
Anders Carlssond67c4c32009-08-16 20:29:29 +00001817 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001818
Anders Carlssond67c4c32009-08-16 20:29:29 +00001819 if (!OperatorDelete) {
Anders Carlsson78f74552009-11-15 18:45:20 +00001820 // Look for a global declaration.
Anders Carlssond67c4c32009-08-16 20:29:29 +00001821 DeclareGlobalNewDelete();
1822 DeclContext *TUDecl = Context.getTranslationUnitDecl();
John Wiegley429bb272011-04-08 18:41:53 +00001823 Expr *Arg = Ex.get();
Mike Stump1eb44332009-09-09 15:08:12 +00001824 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName,
John Wiegley429bb272011-04-08 18:41:53 +00001825 &Arg, 1, TUDecl, /*AllowMissing=*/false,
Anders Carlssond67c4c32009-08-16 20:29:29 +00001826 OperatorDelete))
1827 return ExprError();
1828 }
Mike Stump1eb44332009-09-09 15:08:12 +00001829
John McCall9c82afc2010-04-20 02:18:25 +00001830 MarkDeclarationReferenced(StartLoc, OperatorDelete);
John McCall6ec278d2011-01-27 09:37:56 +00001831
Douglas Gregord880f522011-02-01 15:50:11 +00001832 // Check access and ambiguity of operator delete and destructor.
1833 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) {
1834 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1835 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) {
John Wiegley429bb272011-04-08 18:41:53 +00001836 CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
Douglas Gregord880f522011-02-01 15:50:11 +00001837 PDiag(diag::err_access_dtor) << PointeeElem);
1838 }
1839 }
1840
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001841 }
1842
Sebastian Redlf53597f2009-03-15 17:47:39 +00001843 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
John McCall6ec278d2011-01-27 09:37:56 +00001844 ArrayFormAsWritten,
1845 UsualArrayDeleteWantsSize,
John Wiegley429bb272011-04-08 18:41:53 +00001846 OperatorDelete, Ex.take(), StartLoc));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001847}
1848
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001849/// \brief Check the use of the given variable as a C++ condition in an if,
1850/// while, do-while, or switch statement.
John McCall60d7b3a2010-08-24 06:29:42 +00001851ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
John McCallf89e55a2010-11-18 06:31:45 +00001852 SourceLocation StmtLoc,
1853 bool ConvertToBoolean) {
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001854 QualType T = ConditionVar->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001855
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001856 // C++ [stmt.select]p2:
1857 // The declarator shall not specify a function or an array.
1858 if (T->isFunctionType())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001859 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001860 diag::err_invalid_use_of_function_type)
1861 << ConditionVar->getSourceRange());
1862 else if (T->isArrayType())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001863 return ExprError(Diag(ConditionVar->getLocation(),
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001864 diag::err_invalid_use_of_array_type)
1865 << ConditionVar->getSourceRange());
Douglas Gregora7605db2009-11-24 16:07:02 +00001866
John Wiegley429bb272011-04-08 18:41:53 +00001867 ExprResult Condition =
1868 Owned(DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
Douglas Gregor40d96a62011-02-28 21:54:11 +00001869 ConditionVar,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001870 ConditionVar->getLocation(),
John McCallf89e55a2010-11-18 06:31:45 +00001871 ConditionVar->getType().getNonReferenceType(),
John Wiegley429bb272011-04-08 18:41:53 +00001872 VK_LValue));
1873 if (ConvertToBoolean) {
1874 Condition = CheckBooleanCondition(Condition.take(), StmtLoc);
1875 if (Condition.isInvalid())
1876 return ExprError();
1877 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001878
John Wiegley429bb272011-04-08 18:41:53 +00001879 return move(Condition);
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001880}
1881
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001882/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
John Wiegley429bb272011-04-08 18:41:53 +00001883ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr) {
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001884 // C++ 6.4p4:
1885 // The value of a condition that is an initialized declaration in a statement
1886 // other than a switch statement is the value of the declared variable
1887 // implicitly converted to type bool. If that conversion is ill-formed, the
1888 // program is ill-formed.
1889 // The value of a condition that is an expression is the value of the
1890 // expression, implicitly converted to bool.
1891 //
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001892 return PerformContextuallyConvertToBool(CondExpr);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001893}
Douglas Gregor77a52232008-09-12 00:47:35 +00001894
1895/// Helper function to determine whether this is the (deprecated) C++
1896/// conversion from a string literal to a pointer to non-const char or
1897/// non-const wchar_t (for narrow and wide string literals,
1898/// respectively).
Mike Stump1eb44332009-09-09 15:08:12 +00001899bool
Douglas Gregor77a52232008-09-12 00:47:35 +00001900Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
1901 // Look inside the implicit cast, if it exists.
1902 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
1903 From = Cast->getSubExpr();
1904
1905 // A string literal (2.13.4) that is not a wide string literal can
1906 // be converted to an rvalue of type "pointer to char"; a wide
1907 // string literal can be converted to an rvalue of type "pointer
1908 // to wchar_t" (C++ 4.2p2).
Douglas Gregor1984eb92010-06-22 23:47:37 +00001909 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
Ted Kremenek6217b802009-07-29 21:53:49 +00001910 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
Mike Stump1eb44332009-09-09 15:08:12 +00001911 if (const BuiltinType *ToPointeeType
John McCall183700f2009-09-21 23:43:11 +00001912 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
Douglas Gregor77a52232008-09-12 00:47:35 +00001913 // This conversion is considered only when there is an
1914 // explicit appropriate pointer target type (C++ 4.2p2).
John McCall0953e762009-09-24 19:53:00 +00001915 if (!ToPtrType->getPointeeType().hasQualifiers() &&
Douglas Gregor77a52232008-09-12 00:47:35 +00001916 ((StrLit->isWide() && ToPointeeType->isWideCharType()) ||
1917 (!StrLit->isWide() &&
1918 (ToPointeeType->getKind() == BuiltinType::Char_U ||
1919 ToPointeeType->getKind() == BuiltinType::Char_S))))
1920 return true;
1921 }
1922
1923 return false;
1924}
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001925
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001926static ExprResult BuildCXXCastArgument(Sema &S,
John McCall2de56d12010-08-25 11:45:40 +00001927 SourceLocation CastLoc,
1928 QualType Ty,
1929 CastKind Kind,
1930 CXXMethodDecl *Method,
Douglas Gregor83eecbe2011-01-20 01:32:05 +00001931 NamedDecl *FoundDecl,
John McCall2de56d12010-08-25 11:45:40 +00001932 Expr *From) {
Douglas Gregorba70ab62010-04-16 22:17:36 +00001933 switch (Kind) {
1934 default: assert(0 && "Unhandled cast kind!");
John McCall2de56d12010-08-25 11:45:40 +00001935 case CK_ConstructorConversion: {
John McCallca0408f2010-08-23 06:44:23 +00001936 ASTOwningVector<Expr*> ConstructorArgs(S);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001937
Douglas Gregorba70ab62010-04-16 22:17:36 +00001938 if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method),
John McCallf312b1e2010-08-26 23:41:50 +00001939 MultiExprArg(&From, 1),
Douglas Gregorba70ab62010-04-16 22:17:36 +00001940 CastLoc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00001941 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001942
1943 ExprResult Result =
1944 S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method),
John McCall7a1fad32010-08-24 07:32:53 +00001945 move_arg(ConstructorArgs),
Chandler Carruth428edaf2010-10-25 08:47:36 +00001946 /*ZeroInit*/ false, CXXConstructExpr::CK_Complete,
1947 SourceRange());
Douglas Gregorba70ab62010-04-16 22:17:36 +00001948 if (Result.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00001949 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001950
Douglas Gregorba70ab62010-04-16 22:17:36 +00001951 return S.MaybeBindToTemporary(Result.takeAs<Expr>());
1952 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001953
John McCall2de56d12010-08-25 11:45:40 +00001954 case CK_UserDefinedConversion: {
Douglas Gregorba70ab62010-04-16 22:17:36 +00001955 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001956
Douglas Gregorba70ab62010-04-16 22:17:36 +00001957 // Create an implicit call expr that calls it.
Douglas Gregor83eecbe2011-01-20 01:32:05 +00001958 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Method);
Douglas Gregorf2ae5262011-01-20 00:18:04 +00001959 if (Result.isInvalid())
1960 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001961
Douglas Gregorf2ae5262011-01-20 00:18:04 +00001962 return S.MaybeBindToTemporary(Result.get());
Douglas Gregorba70ab62010-04-16 22:17:36 +00001963 }
1964 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001965}
Douglas Gregorba70ab62010-04-16 22:17:36 +00001966
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001967/// PerformImplicitConversion - Perform an implicit conversion of the
1968/// expression From to the type ToType using the pre-computed implicit
John Wiegley429bb272011-04-08 18:41:53 +00001969/// conversion sequence ICS. Returns the converted
Douglas Gregor68647482009-12-16 03:45:30 +00001970/// expression. Action is the kind of conversion we're performing,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001971/// used in the error message.
John Wiegley429bb272011-04-08 18:41:53 +00001972ExprResult
1973Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001974 const ImplicitConversionSequence &ICS,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00001975 AssignmentAction Action, bool CStyle) {
John McCall1d318332010-01-12 00:44:57 +00001976 switch (ICS.getKind()) {
John Wiegley429bb272011-04-08 18:41:53 +00001977 case ImplicitConversionSequence::StandardConversion: {
1978 ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
1979 Action, CStyle);
1980 if (Res.isInvalid())
1981 return ExprError();
1982 From = Res.take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001983 break;
John Wiegley429bb272011-04-08 18:41:53 +00001984 }
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001985
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001986 case ImplicitConversionSequence::UserDefinedConversion: {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001987
Fariborz Jahanian7fe5d722009-08-28 22:04:50 +00001988 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
John McCalldaa8e4e2010-11-15 09:13:47 +00001989 CastKind CastKind;
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001990 QualType BeforeToType;
1991 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
John McCall2de56d12010-08-25 11:45:40 +00001992 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001993
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001994 // If the user-defined conversion is specified by a conversion function,
1995 // the initial standard conversion sequence converts the source type to
1996 // the implicit object parameter of the conversion function.
1997 BeforeToType = Context.getTagDeclType(Conv->getParent());
John McCall9ec94452010-12-04 09:57:16 +00001998 } else {
1999 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
John McCall2de56d12010-08-25 11:45:40 +00002000 CastKind = CK_ConstructorConversion;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002001 // Do no conversion if dealing with ... for the first conversion.
Douglas Gregore44201a2009-11-20 02:31:03 +00002002 if (!ICS.UserDefined.EllipsisConversion) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002003 // If the user-defined conversion is specified by a constructor, the
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002004 // initial standard conversion sequence converts the source type to the
2005 // type required by the argument of the constructor
Douglas Gregore44201a2009-11-20 02:31:03 +00002006 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
2007 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002008 }
Douglas Gregora3998bd2010-12-02 21:47:04 +00002009 // Watch out for elipsis conversion.
Fariborz Jahanian4c0cea22009-11-06 00:55:14 +00002010 if (!ICS.UserDefined.EllipsisConversion) {
John Wiegley429bb272011-04-08 18:41:53 +00002011 ExprResult Res =
2012 PerformImplicitConversion(From, BeforeToType,
2013 ICS.UserDefined.Before, AA_Converting,
2014 CStyle);
2015 if (Res.isInvalid())
2016 return ExprError();
2017 From = Res.take();
Fariborz Jahanian966256a2009-11-06 00:23:08 +00002018 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002019
2020 ExprResult CastArg
Douglas Gregorba70ab62010-04-16 22:17:36 +00002021 = BuildCXXCastArgument(*this,
2022 From->getLocStart(),
Anders Carlsson0aebc812009-09-09 21:33:21 +00002023 ToType.getNonReferenceType(),
Douglas Gregor83eecbe2011-01-20 01:32:05 +00002024 CastKind, cast<CXXMethodDecl>(FD),
2025 ICS.UserDefined.FoundConversionFunction,
John McCall9ae2f072010-08-23 23:25:46 +00002026 From);
Anders Carlsson0aebc812009-09-09 21:33:21 +00002027
2028 if (CastArg.isInvalid())
John Wiegley429bb272011-04-08 18:41:53 +00002029 return ExprError();
Eli Friedmand8889622009-11-27 04:41:50 +00002030
John Wiegley429bb272011-04-08 18:41:53 +00002031 From = CastArg.take();
Eli Friedmand8889622009-11-27 04:41:50 +00002032
Eli Friedmand8889622009-11-27 04:41:50 +00002033 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002034 AA_Converting, CStyle);
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00002035 }
John McCall1d318332010-01-12 00:44:57 +00002036
2037 case ImplicitConversionSequence::AmbiguousConversion:
John McCall120d63c2010-08-24 20:38:10 +00002038 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
John McCall1d318332010-01-12 00:44:57 +00002039 PDiag(diag::err_typecheck_ambiguous_condition)
2040 << From->getSourceRange());
John Wiegley429bb272011-04-08 18:41:53 +00002041 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002042
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002043 case ImplicitConversionSequence::EllipsisConversion:
2044 assert(false && "Cannot perform an ellipsis conversion");
John Wiegley429bb272011-04-08 18:41:53 +00002045 return Owned(From);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002046
2047 case ImplicitConversionSequence::BadConversion:
John Wiegley429bb272011-04-08 18:41:53 +00002048 return ExprError();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002049 }
2050
2051 // Everything went well.
John Wiegley429bb272011-04-08 18:41:53 +00002052 return Owned(From);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002053}
2054
2055/// PerformImplicitConversion - Perform an implicit conversion of the
2056/// expression From to the type ToType by following the standard
John Wiegley429bb272011-04-08 18:41:53 +00002057/// conversion sequence SCS. Returns the converted
Douglas Gregor45920e82008-12-19 17:40:08 +00002058/// expression. Flavor is the context in which we're performing this
2059/// conversion, for use in error messages.
John Wiegley429bb272011-04-08 18:41:53 +00002060ExprResult
2061Sema::PerformImplicitConversion(Expr *From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00002062 const StandardConversionSequence& SCS,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002063 AssignmentAction Action, bool CStyle) {
Mike Stump390b4cc2009-05-16 07:39:55 +00002064 // Overall FIXME: we are recomputing too many types here and doing far too
2065 // much extra work. What this means is that we need to keep track of more
2066 // information that is computed when we try the implicit conversion initially,
2067 // so that we don't need to recompute anything here.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002068 QualType FromType = From->getType();
2069
Douglas Gregor225c41e2008-11-03 19:09:14 +00002070 if (SCS.CopyConstructor) {
Anders Carlsson7c3e8a12009-05-19 04:45:15 +00002071 // FIXME: When can ToType be a reference type?
2072 assert(!ToType->isReferenceType());
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002073 if (SCS.Second == ICK_Derived_To_Base) {
John McCallca0408f2010-08-23 06:44:23 +00002074 ASTOwningVector<Expr*> ConstructorArgs(*this);
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002075 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
John McCallca0408f2010-08-23 06:44:23 +00002076 MultiExprArg(*this, &From, 1),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002077 /*FIXME:ConstructLoc*/SourceLocation(),
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002078 ConstructorArgs))
John Wiegley429bb272011-04-08 18:41:53 +00002079 return ExprError();
2080 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2081 ToType, SCS.CopyConstructor,
2082 move_arg(ConstructorArgs),
2083 /*ZeroInit*/ false,
2084 CXXConstructExpr::CK_Complete,
2085 SourceRange());
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00002086 }
John Wiegley429bb272011-04-08 18:41:53 +00002087 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
2088 ToType, SCS.CopyConstructor,
2089 MultiExprArg(*this, &From, 1),
2090 /*ZeroInit*/ false,
2091 CXXConstructExpr::CK_Complete,
2092 SourceRange());
Douglas Gregor225c41e2008-11-03 19:09:14 +00002093 }
2094
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002095 // Resolve overloaded function references.
2096 if (Context.hasSameType(FromType, Context.OverloadTy)) {
2097 DeclAccessPair Found;
2098 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
2099 true, Found);
2100 if (!Fn)
John Wiegley429bb272011-04-08 18:41:53 +00002101 return ExprError();
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002102
2103 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
John Wiegley429bb272011-04-08 18:41:53 +00002104 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002105
Douglas Gregorad4e02f2010-04-29 18:24:40 +00002106 From = FixOverloadedFunctionReference(From, Found, Fn);
2107 FromType = From->getType();
2108 }
2109
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002110 // Perform the first implicit conversion.
2111 switch (SCS.First) {
2112 case ICK_Identity:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002113 // Nothing to do.
2114 break;
2115
John McCallf6a16482010-12-04 03:47:34 +00002116 case ICK_Lvalue_To_Rvalue:
2117 // Should this get its own ICK?
2118 if (From->getObjectKind() == OK_ObjCProperty) {
John Wiegley429bb272011-04-08 18:41:53 +00002119 ExprResult FromRes = ConvertPropertyForRValue(From);
2120 if (FromRes.isInvalid())
2121 return ExprError();
2122 From = FromRes.take();
John McCall241d5582010-12-07 22:54:16 +00002123 if (!From->isGLValue()) break;
John McCallf6a16482010-12-04 03:47:34 +00002124 }
2125
Chandler Carruth35001ca2011-02-17 21:10:52 +00002126 // Check for trivial buffer overflows.
Ted Kremenek3aea4da2011-03-01 18:41:00 +00002127 CheckArrayAccess(From);
Chandler Carruth35001ca2011-02-17 21:10:52 +00002128
John McCallf6a16482010-12-04 03:47:34 +00002129 FromType = FromType.getUnqualifiedType();
2130 From = ImplicitCastExpr::Create(Context, FromType, CK_LValueToRValue,
2131 From, 0, VK_RValue);
2132 break;
2133
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002134 case ICK_Array_To_Pointer:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002135 FromType = Context.getArrayDecayedType(FromType);
John Wiegley429bb272011-04-08 18:41:53 +00002136 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay).take();
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002137 break;
2138
2139 case ICK_Function_To_Pointer:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002140 FromType = Context.getPointerType(FromType);
John Wiegley429bb272011-04-08 18:41:53 +00002141 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002142 break;
2143
2144 default:
2145 assert(false && "Improper first standard conversion");
2146 break;
2147 }
2148
2149 // Perform the second implicit conversion
2150 switch (SCS.Second) {
2151 case ICK_Identity:
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002152 // If both sides are functions (or pointers/references to them), there could
2153 // be incompatible exception declarations.
2154 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002155 return ExprError();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002156 // Nothing else to do.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002157 break;
2158
Douglas Gregor43c79c22009-12-09 00:47:37 +00002159 case ICK_NoReturn_Adjustment:
2160 // If both sides are functions (or pointers/references to them), there could
2161 // be incompatible exception declarations.
2162 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002163 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002164
John Wiegley429bb272011-04-08 18:41:53 +00002165 From = ImpCastExprToType(From, ToType, CK_NoOp).take();
Douglas Gregor43c79c22009-12-09 00:47:37 +00002166 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002167
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002168 case ICK_Integral_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002169 case ICK_Integral_Conversion:
John Wiegley429bb272011-04-08 18:41:53 +00002170 From = ImpCastExprToType(From, ToType, CK_IntegralCast).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002171 break;
2172
2173 case ICK_Floating_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002174 case ICK_Floating_Conversion:
John Wiegley429bb272011-04-08 18:41:53 +00002175 From = ImpCastExprToType(From, ToType, CK_FloatingCast).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002176 break;
2177
2178 case ICK_Complex_Promotion:
John McCalldaa8e4e2010-11-15 09:13:47 +00002179 case ICK_Complex_Conversion: {
2180 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
2181 QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
2182 CastKind CK;
2183 if (FromEl->isRealFloatingType()) {
2184 if (ToEl->isRealFloatingType())
2185 CK = CK_FloatingComplexCast;
2186 else
2187 CK = CK_FloatingComplexToIntegralComplex;
2188 } else if (ToEl->isRealFloatingType()) {
2189 CK = CK_IntegralComplexToFloatingComplex;
2190 } else {
2191 CK = CK_IntegralComplexCast;
2192 }
John Wiegley429bb272011-04-08 18:41:53 +00002193 From = ImpCastExprToType(From, ToType, CK).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002194 break;
John McCalldaa8e4e2010-11-15 09:13:47 +00002195 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00002196
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002197 case ICK_Floating_Integral:
Douglas Gregor0c293ea2010-06-22 23:07:26 +00002198 if (ToType->isRealFloatingType())
John Wiegley429bb272011-04-08 18:41:53 +00002199 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002200 else
John Wiegley429bb272011-04-08 18:41:53 +00002201 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00002202 break;
2203
Douglas Gregorf9201e02009-02-11 23:02:49 +00002204 case ICK_Compatible_Conversion:
John Wiegley429bb272011-04-08 18:41:53 +00002205 From = ImpCastExprToType(From, ToType, CK_NoOp).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002206 break;
2207
Anders Carlsson61faec12009-09-12 04:46:44 +00002208 case ICK_Pointer_Conversion: {
Douglas Gregora3998bd2010-12-02 21:47:04 +00002209 if (SCS.IncompatibleObjC && Action != AA_Casting) {
Douglas Gregor45920e82008-12-19 17:40:08 +00002210 // Diagnose incompatible Objective-C conversions
Fariborz Jahanian84950c72011-03-21 19:08:42 +00002211 if (Action == AA_Initializing)
2212 Diag(From->getSourceRange().getBegin(),
2213 diag::ext_typecheck_convert_incompatible_pointer)
2214 << ToType << From->getType() << Action
2215 << From->getSourceRange();
2216 else
2217 Diag(From->getSourceRange().getBegin(),
2218 diag::ext_typecheck_convert_incompatible_pointer)
2219 << From->getType() << ToType << Action
2220 << From->getSourceRange();
Douglas Gregor45920e82008-12-19 17:40:08 +00002221 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002222
John McCalldaa8e4e2010-11-15 09:13:47 +00002223 CastKind Kind = CK_Invalid;
John McCallf871d0c2010-08-07 06:22:56 +00002224 CXXCastPath BasePath;
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002225 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002226 return ExprError();
2227 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002228 break;
Anders Carlsson61faec12009-09-12 04:46:44 +00002229 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002230
Anders Carlsson61faec12009-09-12 04:46:44 +00002231 case ICK_Pointer_Member: {
John McCalldaa8e4e2010-11-15 09:13:47 +00002232 CastKind Kind = CK_Invalid;
John McCallf871d0c2010-08-07 06:22:56 +00002233 CXXCastPath BasePath;
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002234 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002235 return ExprError();
Sebastian Redl2c7588f2009-10-10 12:04:10 +00002236 if (CheckExceptionSpecCompatibility(From, ToType))
John Wiegley429bb272011-04-08 18:41:53 +00002237 return ExprError();
2238 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath).take();
Anders Carlsson61faec12009-09-12 04:46:44 +00002239 break;
2240 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002241
Abramo Bagnara737d5442011-04-07 09:26:19 +00002242 case ICK_Boolean_Conversion:
John Wiegley429bb272011-04-08 18:41:53 +00002243 From = ImpCastExprToType(From, Context.BoolTy,
2244 ScalarTypeToBooleanCastKind(FromType)).take();
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002245 break;
2246
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002247 case ICK_Derived_To_Base: {
John McCallf871d0c2010-08-07 06:22:56 +00002248 CXXCastPath BasePath;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002249 if (CheckDerivedToBaseConversion(From->getType(),
Douglas Gregorb7a86f52009-11-06 01:02:41 +00002250 ToType.getNonReferenceType(),
2251 From->getLocStart(),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002252 From->getSourceRange(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002253 &BasePath,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00002254 CStyle))
John Wiegley429bb272011-04-08 18:41:53 +00002255 return ExprError();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002256
John Wiegley429bb272011-04-08 18:41:53 +00002257 From = ImpCastExprToType(From, ToType.getNonReferenceType(),
John McCall2de56d12010-08-25 11:45:40 +00002258 CK_DerivedToBase, CastCategory(From),
John Wiegley429bb272011-04-08 18:41:53 +00002259 &BasePath).take();
Douglas Gregorb7a86f52009-11-06 01:02:41 +00002260 break;
Douglas Gregor6fb745b2010-05-13 16:44:06 +00002261 }
2262
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002263 case ICK_Vector_Conversion:
John Wiegley429bb272011-04-08 18:41:53 +00002264 From = ImpCastExprToType(From, ToType, CK_BitCast).take();
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002265 break;
2266
2267 case ICK_Vector_Splat:
John Wiegley429bb272011-04-08 18:41:53 +00002268 From = ImpCastExprToType(From, ToType, CK_VectorSplat).take();
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002269 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002270
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002271 case ICK_Complex_Real:
John McCalldaa8e4e2010-11-15 09:13:47 +00002272 // Case 1. x -> _Complex y
2273 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
2274 QualType ElType = ToComplex->getElementType();
2275 bool isFloatingComplex = ElType->isRealFloatingType();
2276
2277 // x -> y
2278 if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
2279 // do nothing
2280 } else if (From->getType()->isRealFloatingType()) {
John Wiegley429bb272011-04-08 18:41:53 +00002281 From = ImpCastExprToType(From, ElType,
2282 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002283 } else {
2284 assert(From->getType()->isIntegerType());
John Wiegley429bb272011-04-08 18:41:53 +00002285 From = ImpCastExprToType(From, ElType,
2286 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002287 }
2288 // y -> _Complex y
John Wiegley429bb272011-04-08 18:41:53 +00002289 From = ImpCastExprToType(From, ToType,
John McCalldaa8e4e2010-11-15 09:13:47 +00002290 isFloatingComplex ? CK_FloatingRealToComplex
John Wiegley429bb272011-04-08 18:41:53 +00002291 : CK_IntegralRealToComplex).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002292
2293 // Case 2. _Complex x -> y
2294 } else {
2295 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
2296 assert(FromComplex);
2297
2298 QualType ElType = FromComplex->getElementType();
2299 bool isFloatingComplex = ElType->isRealFloatingType();
2300
2301 // _Complex x -> x
John Wiegley429bb272011-04-08 18:41:53 +00002302 From = ImpCastExprToType(From, ElType,
John McCalldaa8e4e2010-11-15 09:13:47 +00002303 isFloatingComplex ? CK_FloatingComplexToReal
John Wiegley429bb272011-04-08 18:41:53 +00002304 : CK_IntegralComplexToReal).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002305
2306 // x -> y
2307 if (Context.hasSameUnqualifiedType(ElType, ToType)) {
2308 // do nothing
2309 } else if (ToType->isRealFloatingType()) {
John Wiegley429bb272011-04-08 18:41:53 +00002310 From = ImpCastExprToType(From, ToType,
2311 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002312 } else {
2313 assert(ToType->isIntegerType());
John Wiegley429bb272011-04-08 18:41:53 +00002314 From = ImpCastExprToType(From, ToType,
2315 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast).take();
John McCalldaa8e4e2010-11-15 09:13:47 +00002316 }
2317 }
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002318 break;
Fariborz Jahaniane3c8c642011-02-12 19:07:46 +00002319
2320 case ICK_Block_Pointer_Conversion: {
John Wiegley429bb272011-04-08 18:41:53 +00002321 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
2322 VK_RValue).take();
Fariborz Jahaniane3c8c642011-02-12 19:07:46 +00002323 break;
2324 }
2325
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002326 case ICK_TransparentUnionConversion: {
John Wiegley429bb272011-04-08 18:41:53 +00002327 ExprResult FromRes = Owned(From);
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002328 Sema::AssignConvertType ConvTy =
John Wiegley429bb272011-04-08 18:41:53 +00002329 CheckTransparentUnionArgumentConstraints(ToType, FromRes);
2330 if (FromRes.isInvalid())
2331 return ExprError();
2332 From = FromRes.take();
Fariborz Jahaniand97f5582011-03-23 19:50:54 +00002333 assert ((ConvTy == Sema::Compatible) &&
2334 "Improper transparent union conversion");
2335 (void)ConvTy;
2336 break;
2337 }
2338
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002339 case ICK_Lvalue_To_Rvalue:
2340 case ICK_Array_To_Pointer:
2341 case ICK_Function_To_Pointer:
2342 case ICK_Qualification:
2343 case ICK_Num_Conversion_Kinds:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002344 assert(false && "Improper second standard conversion");
2345 break;
2346 }
2347
2348 switch (SCS.Third) {
2349 case ICK_Identity:
2350 // Nothing to do.
2351 break;
2352
Sebastian Redl906082e2010-07-20 04:20:21 +00002353 case ICK_Qualification: {
2354 // The qualification keeps the category of the inner expression, unless the
2355 // target type isn't a reference.
John McCall5baba9d2010-08-25 10:28:54 +00002356 ExprValueKind VK = ToType->isReferenceType() ?
2357 CastCategory(From) : VK_RValue;
John Wiegley429bb272011-04-08 18:41:53 +00002358 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
2359 CK_NoOp, VK).take();
Douglas Gregora9bff302010-02-28 18:30:25 +00002360
Douglas Gregor069a6da2011-03-14 16:13:32 +00002361 if (SCS.DeprecatedStringLiteralToCharPtr &&
2362 !getLangOptions().WritableStrings)
Douglas Gregora9bff302010-02-28 18:30:25 +00002363 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion)
2364 << ToType.getNonReferenceType();
2365
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002366 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002367 }
2368
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002369 default:
Douglas Gregorfb4a5432010-05-18 22:42:18 +00002370 assert(false && "Improper third standard conversion");
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002371 break;
2372 }
2373
John Wiegley429bb272011-04-08 18:41:53 +00002374 return Owned(From);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002375}
2376
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002377ExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT,
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002378 SourceLocation KWLoc,
2379 ParsedType Ty,
2380 SourceLocation RParen) {
2381 TypeSourceInfo *TSInfo;
2382 QualType T = GetTypeFromParser(Ty, &TSInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00002383
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002384 if (!TSInfo)
2385 TSInfo = Context.getTrivialTypeSourceInfo(T);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002386 return BuildUnaryTypeTrait(UTT, KWLoc, TSInfo, RParen);
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002387}
2388
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002389/// \brief Check the completeness of a type in a unary type trait.
2390///
2391/// If the particular type trait requires a complete type, tries to complete
2392/// it. If completing the type fails, a diagnostic is emitted and false
2393/// returned. If completing the type succeeds or no completion was required,
2394/// returns true.
2395static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S,
2396 UnaryTypeTrait UTT,
2397 SourceLocation Loc,
2398 QualType ArgTy) {
2399 // C++0x [meta.unary.prop]p3:
2400 // For all of the class templates X declared in this Clause, instantiating
2401 // that template with a template argument that is a class template
2402 // specialization may result in the implicit instantiation of the template
2403 // argument if and only if the semantics of X require that the argument
2404 // must be a complete type.
2405 // We apply this rule to all the type trait expressions used to implement
2406 // these class templates. We also try to follow any GCC documented behavior
2407 // in these expressions to ensure portability of standard libraries.
2408 switch (UTT) {
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002409 // is_complete_type somewhat obviously cannot require a complete type.
2410 case UTT_IsCompleteType:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002411 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002412
2413 // These traits are modeled on the type predicates in C++0x
2414 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
2415 // requiring a complete type, as whether or not they return true cannot be
2416 // impacted by the completeness of the type.
2417 case UTT_IsVoid:
2418 case UTT_IsIntegral:
2419 case UTT_IsFloatingPoint:
2420 case UTT_IsArray:
2421 case UTT_IsPointer:
2422 case UTT_IsLvalueReference:
2423 case UTT_IsRvalueReference:
2424 case UTT_IsMemberFunctionPointer:
2425 case UTT_IsMemberObjectPointer:
2426 case UTT_IsEnum:
2427 case UTT_IsUnion:
2428 case UTT_IsClass:
2429 case UTT_IsFunction:
2430 case UTT_IsReference:
2431 case UTT_IsArithmetic:
2432 case UTT_IsFundamental:
2433 case UTT_IsObject:
2434 case UTT_IsScalar:
2435 case UTT_IsCompound:
2436 case UTT_IsMemberPointer:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002437 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002438
2439 // These traits are modeled on type predicates in C++0x [meta.unary.prop]
2440 // which requires some of its traits to have the complete type. However,
2441 // the completeness of the type cannot impact these traits' semantics, and
2442 // so they don't require it. This matches the comments on these traits in
2443 // Table 49.
2444 case UTT_IsConst:
2445 case UTT_IsVolatile:
2446 case UTT_IsSigned:
2447 case UTT_IsUnsigned:
2448 return true;
2449
2450 // C++0x [meta.unary.prop] Table 49 requires the following traits to be
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002451 // applied to a complete type.
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002452 case UTT_IsTrivial:
Sean Huntfeb375d2011-05-13 00:31:07 +00002453 case UTT_IsTriviallyCopyable:
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002454 case UTT_IsStandardLayout:
2455 case UTT_IsPOD:
2456 case UTT_IsLiteral:
2457 case UTT_IsEmpty:
2458 case UTT_IsPolymorphic:
2459 case UTT_IsAbstract:
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002460 // Fall-through
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002461
Chandler Carruthd6efe9b2011-05-01 19:18:02 +00002462 // These trait expressions are designed to help implement predicates in
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002463 // [meta.unary.prop] despite not being named the same. They are specified
2464 // by both GCC and the Embarcadero C++ compiler, and require the complete
2465 // type due to the overarching C++0x type predicates being implemented
2466 // requiring the complete type.
2467 case UTT_HasNothrowAssign:
2468 case UTT_HasNothrowConstructor:
2469 case UTT_HasNothrowCopy:
2470 case UTT_HasTrivialAssign:
Sean Hunt023df372011-05-09 18:22:59 +00002471 case UTT_HasTrivialDefaultConstructor:
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002472 case UTT_HasTrivialCopy:
2473 case UTT_HasTrivialDestructor:
2474 case UTT_HasVirtualDestructor:
2475 // Arrays of unknown bound are expressly allowed.
2476 QualType ElTy = ArgTy;
2477 if (ArgTy->isIncompleteArrayType())
2478 ElTy = S.Context.getAsArrayType(ArgTy)->getElementType();
2479
2480 // The void type is expressly allowed.
2481 if (ElTy->isVoidType())
2482 return true;
2483
2484 return !S.RequireCompleteType(
2485 Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
John Wiegleycf566412011-04-28 02:06:46 +00002486 }
Chandler Carruth73e0a912011-05-01 07:23:17 +00002487 llvm_unreachable("Type trait not handled by switch");
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002488}
2489
2490static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT,
2491 SourceLocation KeyLoc, QualType T) {
Chandler Carruthd064c702011-05-01 08:41:10 +00002492 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegleycf566412011-04-28 02:06:46 +00002493
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002494 ASTContext &C = Self.Context;
2495 switch(UTT) {
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002496 // Type trait expressions corresponding to the primary type category
2497 // predicates in C++0x [meta.unary.cat].
2498 case UTT_IsVoid:
2499 return T->isVoidType();
2500 case UTT_IsIntegral:
2501 return T->isIntegralType(C);
2502 case UTT_IsFloatingPoint:
2503 return T->isFloatingType();
2504 case UTT_IsArray:
2505 return T->isArrayType();
2506 case UTT_IsPointer:
2507 return T->isPointerType();
2508 case UTT_IsLvalueReference:
2509 return T->isLValueReferenceType();
2510 case UTT_IsRvalueReference:
2511 return T->isRValueReferenceType();
2512 case UTT_IsMemberFunctionPointer:
2513 return T->isMemberFunctionPointerType();
2514 case UTT_IsMemberObjectPointer:
2515 return T->isMemberDataPointerType();
2516 case UTT_IsEnum:
2517 return T->isEnumeralType();
Chandler Carruth28eeb382011-05-01 06:11:03 +00002518 case UTT_IsUnion:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002519 return T->isUnionType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002520 case UTT_IsClass:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002521 return T->isClassType() || T->isStructureType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002522 case UTT_IsFunction:
2523 return T->isFunctionType();
2524
2525 // Type trait expressions which correspond to the convenient composition
2526 // predicates in C++0x [meta.unary.comp].
2527 case UTT_IsReference:
2528 return T->isReferenceType();
2529 case UTT_IsArithmetic:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002530 return T->isArithmeticType() && !T->isEnumeralType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002531 case UTT_IsFundamental:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002532 return T->isFundamentalType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002533 case UTT_IsObject:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002534 return T->isObjectType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002535 case UTT_IsScalar:
Chandler Carruthcec0ced2011-05-01 09:29:55 +00002536 return T->isScalarType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002537 case UTT_IsCompound:
Chandler Carruthaaf147b2011-05-01 09:29:58 +00002538 return T->isCompoundType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002539 case UTT_IsMemberPointer:
2540 return T->isMemberPointerType();
2541
2542 // Type trait expressions which correspond to the type property predicates
2543 // in C++0x [meta.unary.prop].
2544 case UTT_IsConst:
2545 return T.isConstQualified();
2546 case UTT_IsVolatile:
2547 return T.isVolatileQualified();
2548 case UTT_IsTrivial:
2549 return T->isTrivialType();
Sean Huntfeb375d2011-05-13 00:31:07 +00002550 case UTT_IsTriviallyCopyable:
2551 return T->isTriviallyCopyableType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002552 case UTT_IsStandardLayout:
2553 return T->isStandardLayoutType();
2554 case UTT_IsPOD:
2555 return T->isPODType();
2556 case UTT_IsLiteral:
2557 return T->isLiteralType();
2558 case UTT_IsEmpty:
2559 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2560 return !RD->isUnion() && RD->isEmpty();
2561 return false;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002562 case UTT_IsPolymorphic:
Chandler Carruth28eeb382011-05-01 06:11:03 +00002563 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2564 return RD->isPolymorphic();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002565 return false;
2566 case UTT_IsAbstract:
Chandler Carruth28eeb382011-05-01 06:11:03 +00002567 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2568 return RD->isAbstract();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002569 return false;
John Wiegley20c0da72011-04-27 23:09:49 +00002570 case UTT_IsSigned:
2571 return T->isSignedIntegerType();
John Wiegley20c0da72011-04-27 23:09:49 +00002572 case UTT_IsUnsigned:
2573 return T->isUnsignedIntegerType();
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002574
2575 // Type trait expressions which query classes regarding their construction,
2576 // destruction, and copying. Rather than being based directly on the
2577 // related type predicates in the standard, they are specified by both
2578 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
2579 // specifications.
2580 //
2581 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
2582 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
Sean Hunt023df372011-05-09 18:22:59 +00002583 case UTT_HasTrivialDefaultConstructor:
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002584 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2585 // If __is_pod (type) is true then the trait is true, else if type is
2586 // a cv class or union type (or array thereof) with a trivial default
2587 // constructor ([class.ctor]) then the trait is true, else it is false.
2588 if (T->isPODType())
2589 return true;
2590 if (const RecordType *RT =
2591 C.getBaseElementType(T)->getAs<RecordType>())
Sean Hunt023df372011-05-09 18:22:59 +00002592 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDefaultConstructor();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002593 return false;
2594 case UTT_HasTrivialCopy:
2595 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2596 // If __is_pod (type) is true or type is a reference type then
2597 // the trait is true, else if type is a cv class or union type
2598 // with a trivial copy constructor ([class.copy]) then the trait
2599 // is true, else it is false.
2600 if (T->isPODType() || T->isReferenceType())
2601 return true;
2602 if (const RecordType *RT = T->getAs<RecordType>())
2603 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor();
2604 return false;
2605 case UTT_HasTrivialAssign:
2606 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2607 // If type is const qualified or is a reference type then the
2608 // trait is false. Otherwise if __is_pod (type) is true then the
2609 // trait is true, else if type is a cv class or union type with
2610 // a trivial copy assignment ([class.copy]) then the trait is
2611 // true, else it is false.
2612 // Note: the const and reference restrictions are interesting,
2613 // given that const and reference members don't prevent a class
2614 // from having a trivial copy assignment operator (but do cause
2615 // errors if the copy assignment operator is actually used, q.v.
2616 // [class.copy]p12).
2617
2618 if (C.getBaseElementType(T).isConstQualified())
2619 return false;
2620 if (T->isPODType())
2621 return true;
2622 if (const RecordType *RT = T->getAs<RecordType>())
2623 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment();
2624 return false;
2625 case UTT_HasTrivialDestructor:
2626 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2627 // If __is_pod (type) is true or type is a reference type
2628 // then the trait is true, else if type is a cv class or union
2629 // type (or array thereof) with a trivial destructor
2630 // ([class.dtor]) then the trait is true, else it is
2631 // false.
2632 if (T->isPODType() || T->isReferenceType())
2633 return true;
2634 if (const RecordType *RT =
2635 C.getBaseElementType(T)->getAs<RecordType>())
2636 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor();
2637 return false;
2638 // TODO: Propagate nothrowness for implicitly declared special members.
2639 case UTT_HasNothrowAssign:
2640 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2641 // If type is const qualified or is a reference type then the
2642 // trait is false. Otherwise if __has_trivial_assign (type)
2643 // is true then the trait is true, else if type is a cv class
2644 // or union type with copy assignment operators that are known
2645 // not to throw an exception then the trait is true, else it is
2646 // false.
2647 if (C.getBaseElementType(T).isConstQualified())
2648 return false;
2649 if (T->isReferenceType())
2650 return false;
2651 if (T->isPODType())
2652 return true;
2653 if (const RecordType *RT = T->getAs<RecordType>()) {
2654 CXXRecordDecl* RD = cast<CXXRecordDecl>(RT->getDecl());
2655 if (RD->hasTrivialCopyAssignment())
2656 return true;
2657
2658 bool FoundAssign = false;
2659 bool AllNoThrow = true;
2660 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(OO_Equal);
Sebastian Redlf8aca862010-09-14 23:40:14 +00002661 LookupResult Res(Self, DeclarationNameInfo(Name, KeyLoc),
2662 Sema::LookupOrdinaryName);
2663 if (Self.LookupQualifiedName(Res, RD)) {
2664 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
2665 Op != OpEnd; ++Op) {
2666 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
2667 if (Operator->isCopyAssignmentOperator()) {
2668 FoundAssign = true;
2669 const FunctionProtoType *CPT
2670 = Operator->getType()->getAs<FunctionProtoType>();
Sebastian Redl8026f6d2011-03-13 17:09:40 +00002671 if (!CPT->isNothrow(Self.Context)) {
Sebastian Redlf8aca862010-09-14 23:40:14 +00002672 AllNoThrow = false;
2673 break;
2674 }
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002675 }
2676 }
2677 }
2678
2679 return FoundAssign && AllNoThrow;
2680 }
2681 return false;
2682 case UTT_HasNothrowCopy:
2683 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2684 // If __has_trivial_copy (type) is true then the trait is true, else
2685 // if type is a cv class or union type with copy constructors that are
2686 // known not to throw an exception then the trait is true, else it is
2687 // false.
2688 if (T->isPODType() || T->isReferenceType())
2689 return true;
2690 if (const RecordType *RT = T->getAs<RecordType>()) {
2691 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
2692 if (RD->hasTrivialCopyConstructor())
2693 return true;
2694
2695 bool FoundConstructor = false;
2696 bool AllNoThrow = true;
2697 unsigned FoundTQs;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002698 DeclContext::lookup_const_iterator Con, ConEnd;
Sebastian Redl5f4e8992010-09-13 21:10:20 +00002699 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002700 Con != ConEnd; ++Con) {
Sebastian Redl08295a52010-09-13 22:18:28 +00002701 // A template constructor is never a copy constructor.
2702 // FIXME: However, it may actually be selected at the actual overload
2703 // resolution point.
2704 if (isa<FunctionTemplateDecl>(*Con))
2705 continue;
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002706 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
2707 if (Constructor->isCopyConstructor(FoundTQs)) {
2708 FoundConstructor = true;
2709 const FunctionProtoType *CPT
2710 = Constructor->getType()->getAs<FunctionProtoType>();
Sebastian Redl60618fa2011-03-12 11:50:43 +00002711 // FIXME: check whether evaluating default arguments can throw.
Sebastian Redl751025d2010-09-13 22:02:47 +00002712 // For now, we'll be conservative and assume that they can throw.
Sebastian Redl8026f6d2011-03-13 17:09:40 +00002713 if (!CPT->isNothrow(Self.Context) || CPT->getNumArgs() > 1) {
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002714 AllNoThrow = false;
2715 break;
2716 }
2717 }
2718 }
2719
2720 return FoundConstructor && AllNoThrow;
2721 }
2722 return false;
2723 case UTT_HasNothrowConstructor:
2724 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2725 // If __has_trivial_constructor (type) is true then the trait is
2726 // true, else if type is a cv class or union type (or array
2727 // thereof) with a default constructor that is known not to
2728 // throw an exception then the trait is true, else it is false.
2729 if (T->isPODType())
2730 return true;
2731 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>()) {
2732 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Sean Hunt023df372011-05-09 18:22:59 +00002733 if (RD->hasTrivialDefaultConstructor())
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002734 return true;
2735
Sebastian Redl751025d2010-09-13 22:02:47 +00002736 DeclContext::lookup_const_iterator Con, ConEnd;
2737 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD);
2738 Con != ConEnd; ++Con) {
Sebastian Redl08295a52010-09-13 22:18:28 +00002739 // FIXME: In C++0x, a constructor template can be a default constructor.
2740 if (isa<FunctionTemplateDecl>(*Con))
2741 continue;
Sebastian Redl751025d2010-09-13 22:02:47 +00002742 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
2743 if (Constructor->isDefaultConstructor()) {
2744 const FunctionProtoType *CPT
2745 = Constructor->getType()->getAs<FunctionProtoType>();
2746 // TODO: check whether evaluating default arguments can throw.
2747 // For now, we'll be conservative and assume that they can throw.
Sebastian Redl8026f6d2011-03-13 17:09:40 +00002748 return CPT->isNothrow(Self.Context) && CPT->getNumArgs() == 0;
Sebastian Redl751025d2010-09-13 22:02:47 +00002749 }
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002750 }
2751 }
2752 return false;
2753 case UTT_HasVirtualDestructor:
2754 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
2755 // If type is a class type with a virtual destructor ([class.dtor])
2756 // then the trait is true, else it is false.
2757 if (const RecordType *Record = T->getAs<RecordType>()) {
2758 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
Sebastian Redlf8aca862010-09-14 23:40:14 +00002759 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002760 return Destructor->isVirtual();
2761 }
2762 return false;
Chandler Carruthc41d6b52011-05-01 06:11:07 +00002763
2764 // These type trait expressions are modeled on the specifications for the
2765 // Embarcadero C++0x type trait functions:
2766 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
2767 case UTT_IsCompleteType:
2768 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
2769 // Returns True if and only if T is a complete type at the point of the
2770 // function call.
2771 return !T->isIncompleteType();
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002772 }
Chandler Carruth83f563c2011-05-01 07:44:17 +00002773 llvm_unreachable("Type trait not covered by switch");
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002774}
2775
2776ExprResult Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT,
Douglas Gregor3d37c0a2010-09-09 16:14:44 +00002777 SourceLocation KWLoc,
2778 TypeSourceInfo *TSInfo,
2779 SourceLocation RParen) {
2780 QualType T = TSInfo->getType();
Chandler Carrutheb65a102011-04-30 10:07:32 +00002781 if (!CheckUnaryTypeTraitTypeCompleteness(*this, UTT, KWLoc, T))
2782 return ExprError();
Sebastian Redl64b45f72009-01-05 20:52:13 +00002783
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002784 bool Value = false;
2785 if (!T->isDependentType())
Chandler Carruthccb4ecf2011-05-01 06:51:22 +00002786 Value = EvaluateUnaryTypeTrait(*this, UTT, KWLoc, T);
Sebastian Redl0dfd8482010-09-13 20:56:31 +00002787
2788 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, UTT, TSInfo, Value,
Anders Carlsson3292d5c2009-07-07 19:06:02 +00002789 RParen, Context.BoolTy));
Sebastian Redl64b45f72009-01-05 20:52:13 +00002790}
Sebastian Redl7c8bd602009-02-07 20:10:22 +00002791
Francois Pichet6ad6f282010-12-07 00:08:36 +00002792ExprResult Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT,
2793 SourceLocation KWLoc,
2794 ParsedType LhsTy,
2795 ParsedType RhsTy,
2796 SourceLocation RParen) {
2797 TypeSourceInfo *LhsTSInfo;
2798 QualType LhsT = GetTypeFromParser(LhsTy, &LhsTSInfo);
2799 if (!LhsTSInfo)
2800 LhsTSInfo = Context.getTrivialTypeSourceInfo(LhsT);
2801
2802 TypeSourceInfo *RhsTSInfo;
2803 QualType RhsT = GetTypeFromParser(RhsTy, &RhsTSInfo);
2804 if (!RhsTSInfo)
2805 RhsTSInfo = Context.getTrivialTypeSourceInfo(RhsT);
2806
2807 return BuildBinaryTypeTrait(BTT, KWLoc, LhsTSInfo, RhsTSInfo, RParen);
2808}
2809
2810static bool EvaluateBinaryTypeTrait(Sema &Self, BinaryTypeTrait BTT,
2811 QualType LhsT, QualType RhsT,
2812 SourceLocation KeyLoc) {
Chandler Carruthd064c702011-05-01 08:41:10 +00002813 assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
2814 "Cannot evaluate traits of dependent types");
Francois Pichet6ad6f282010-12-07 00:08:36 +00002815
2816 switch(BTT) {
John McCalld89d30f2011-01-28 22:02:36 +00002817 case BTT_IsBaseOf: {
Francois Pichet6ad6f282010-12-07 00:08:36 +00002818 // C++0x [meta.rel]p2
John McCalld89d30f2011-01-28 22:02:36 +00002819 // Base is a base class of Derived without regard to cv-qualifiers or
Francois Pichet6ad6f282010-12-07 00:08:36 +00002820 // Base and Derived are not unions and name the same class type without
2821 // regard to cv-qualifiers.
Francois Pichet6ad6f282010-12-07 00:08:36 +00002822
John McCalld89d30f2011-01-28 22:02:36 +00002823 const RecordType *lhsRecord = LhsT->getAs<RecordType>();
2824 if (!lhsRecord) return false;
2825
2826 const RecordType *rhsRecord = RhsT->getAs<RecordType>();
2827 if (!rhsRecord) return false;
2828
2829 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
2830 == (lhsRecord == rhsRecord));
2831
2832 if (lhsRecord == rhsRecord)
2833 return !lhsRecord->getDecl()->isUnion();
2834
2835 // C++0x [meta.rel]p2:
2836 // If Base and Derived are class types and are different types
2837 // (ignoring possible cv-qualifiers) then Derived shall be a
2838 // complete type.
2839 if (Self.RequireCompleteType(KeyLoc, RhsT,
2840 diag::err_incomplete_type_used_in_type_trait_expr))
2841 return false;
2842
2843 return cast<CXXRecordDecl>(rhsRecord->getDecl())
2844 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
2845 }
John Wiegley20c0da72011-04-27 23:09:49 +00002846 case BTT_IsSame:
2847 return Self.Context.hasSameType(LhsT, RhsT);
Francois Pichetf1872372010-12-08 22:35:30 +00002848 case BTT_TypeCompatible:
2849 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(),
2850 RhsT.getUnqualifiedType());
John Wiegley20c0da72011-04-27 23:09:49 +00002851 case BTT_IsConvertible:
Douglas Gregor9f361132011-01-27 20:28:01 +00002852 case BTT_IsConvertibleTo: {
2853 // C++0x [meta.rel]p4:
2854 // Given the following function prototype:
2855 //
2856 // template <class T>
2857 // typename add_rvalue_reference<T>::type create();
2858 //
2859 // the predicate condition for a template specialization
2860 // is_convertible<From, To> shall be satisfied if and only if
2861 // the return expression in the following code would be
2862 // well-formed, including any implicit conversions to the return
2863 // type of the function:
2864 //
2865 // To test() {
2866 // return create<From>();
2867 // }
2868 //
2869 // Access checking is performed as if in a context unrelated to To and
2870 // From. Only the validity of the immediate context of the expression
2871 // of the return-statement (including conversions to the return type)
2872 // is considered.
2873 //
2874 // We model the initialization as a copy-initialization of a temporary
2875 // of the appropriate type, which for this expression is identical to the
2876 // return statement (since NRVO doesn't apply).
2877 if (LhsT->isObjectType() || LhsT->isFunctionType())
2878 LhsT = Self.Context.getRValueReferenceType(LhsT);
2879
2880 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
Douglas Gregorb608b982011-01-28 02:26:04 +00002881 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
Douglas Gregor9f361132011-01-27 20:28:01 +00002882 Expr::getValueKindForType(LhsT));
2883 Expr *FromPtr = &From;
2884 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
2885 SourceLocation()));
2886
Douglas Gregor1eee5dc2011-01-27 22:31:44 +00002887 // Perform the initialization within a SFINAE trap at translation unit
2888 // scope.
2889 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
2890 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
Douglas Gregor9f361132011-01-27 20:28:01 +00002891 InitializationSequence Init(Self, To, Kind, &FromPtr, 1);
Sebastian Redl383616c2011-06-05 12:23:28 +00002892 if (Init.Failed())
Douglas Gregor9f361132011-01-27 20:28:01 +00002893 return false;
Douglas Gregor1eee5dc2011-01-27 22:31:44 +00002894
Douglas Gregor9f361132011-01-27 20:28:01 +00002895 ExprResult Result = Init.Perform(Self, To, Kind, MultiExprArg(&FromPtr, 1));
2896 return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
2897 }
Francois Pichet6ad6f282010-12-07 00:08:36 +00002898 }
2899 llvm_unreachable("Unknown type trait or not implemented");
2900}
2901
2902ExprResult Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT,
2903 SourceLocation KWLoc,
2904 TypeSourceInfo *LhsTSInfo,
2905 TypeSourceInfo *RhsTSInfo,
2906 SourceLocation RParen) {
2907 QualType LhsT = LhsTSInfo->getType();
2908 QualType RhsT = RhsTSInfo->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002909
John McCalld89d30f2011-01-28 22:02:36 +00002910 if (BTT == BTT_TypeCompatible) {
Francois Pichetf1872372010-12-08 22:35:30 +00002911 if (getLangOptions().CPlusPlus) {
2912 Diag(KWLoc, diag::err_types_compatible_p_in_cplusplus)
2913 << SourceRange(KWLoc, RParen);
2914 return ExprError();
2915 }
Francois Pichet6ad6f282010-12-07 00:08:36 +00002916 }
2917
2918 bool Value = false;
2919 if (!LhsT->isDependentType() && !RhsT->isDependentType())
2920 Value = EvaluateBinaryTypeTrait(*this, BTT, LhsT, RhsT, KWLoc);
2921
Francois Pichetf1872372010-12-08 22:35:30 +00002922 // Select trait result type.
2923 QualType ResultType;
2924 switch (BTT) {
Francois Pichetf1872372010-12-08 22:35:30 +00002925 case BTT_IsBaseOf: ResultType = Context.BoolTy; break;
John Wiegley20c0da72011-04-27 23:09:49 +00002926 case BTT_IsConvertible: ResultType = Context.BoolTy; break;
2927 case BTT_IsSame: ResultType = Context.BoolTy; break;
Francois Pichetf1872372010-12-08 22:35:30 +00002928 case BTT_TypeCompatible: ResultType = Context.IntTy; break;
Douglas Gregor9f361132011-01-27 20:28:01 +00002929 case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break;
Francois Pichetf1872372010-12-08 22:35:30 +00002930 }
2931
Francois Pichet6ad6f282010-12-07 00:08:36 +00002932 return Owned(new (Context) BinaryTypeTraitExpr(KWLoc, BTT, LhsTSInfo,
2933 RhsTSInfo, Value, RParen,
Francois Pichetf1872372010-12-08 22:35:30 +00002934 ResultType));
Francois Pichet6ad6f282010-12-07 00:08:36 +00002935}
2936
John Wiegley21ff2e52011-04-28 00:16:57 +00002937ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
2938 SourceLocation KWLoc,
2939 ParsedType Ty,
2940 Expr* DimExpr,
2941 SourceLocation RParen) {
2942 TypeSourceInfo *TSInfo;
2943 QualType T = GetTypeFromParser(Ty, &TSInfo);
2944 if (!TSInfo)
2945 TSInfo = Context.getTrivialTypeSourceInfo(T);
2946
2947 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
2948}
2949
2950static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
2951 QualType T, Expr *DimExpr,
2952 SourceLocation KeyLoc) {
Chandler Carruthd064c702011-05-01 08:41:10 +00002953 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
John Wiegley21ff2e52011-04-28 00:16:57 +00002954
2955 switch(ATT) {
2956 case ATT_ArrayRank:
2957 if (T->isArrayType()) {
2958 unsigned Dim = 0;
2959 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
2960 ++Dim;
2961 T = AT->getElementType();
2962 }
2963 return Dim;
John Wiegley21ff2e52011-04-28 00:16:57 +00002964 }
John Wiegleycf566412011-04-28 02:06:46 +00002965 return 0;
2966
John Wiegley21ff2e52011-04-28 00:16:57 +00002967 case ATT_ArrayExtent: {
2968 llvm::APSInt Value;
2969 uint64_t Dim;
John Wiegleycf566412011-04-28 02:06:46 +00002970 if (DimExpr->isIntegerConstantExpr(Value, Self.Context, 0, false)) {
2971 if (Value < llvm::APSInt(Value.getBitWidth(), Value.isUnsigned())) {
2972 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer) <<
2973 DimExpr->getSourceRange();
2974 return false;
2975 }
John Wiegley21ff2e52011-04-28 00:16:57 +00002976 Dim = Value.getLimitedValue();
John Wiegleycf566412011-04-28 02:06:46 +00002977 } else {
2978 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer) <<
2979 DimExpr->getSourceRange();
2980 return false;
2981 }
John Wiegley21ff2e52011-04-28 00:16:57 +00002982
2983 if (T->isArrayType()) {
2984 unsigned D = 0;
2985 bool Matched = false;
2986 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
2987 if (Dim == D) {
2988 Matched = true;
2989 break;
2990 }
2991 ++D;
2992 T = AT->getElementType();
2993 }
2994
John Wiegleycf566412011-04-28 02:06:46 +00002995 if (Matched && T->isArrayType()) {
2996 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
2997 return CAT->getSize().getLimitedValue();
2998 }
John Wiegley21ff2e52011-04-28 00:16:57 +00002999 }
John Wiegleycf566412011-04-28 02:06:46 +00003000 return 0;
John Wiegley21ff2e52011-04-28 00:16:57 +00003001 }
3002 }
3003 llvm_unreachable("Unknown type trait or not implemented");
3004}
3005
3006ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT,
3007 SourceLocation KWLoc,
3008 TypeSourceInfo *TSInfo,
3009 Expr* DimExpr,
3010 SourceLocation RParen) {
3011 QualType T = TSInfo->getType();
John Wiegley21ff2e52011-04-28 00:16:57 +00003012
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003013 // FIXME: This should likely be tracked as an APInt to remove any host
3014 // assumptions about the width of size_t on the target.
Chandler Carruthd064c702011-05-01 08:41:10 +00003015 uint64_t Value = 0;
3016 if (!T->isDependentType())
3017 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
3018
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003019 // While the specification for these traits from the Embarcadero C++
3020 // compiler's documentation says the return type is 'unsigned int', Clang
3021 // returns 'size_t'. On Windows, the primary platform for the Embarcadero
3022 // compiler, there is no difference. On several other platforms this is an
3023 // important distinction.
John Wiegley21ff2e52011-04-28 00:16:57 +00003024 return Owned(new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value,
Chandler Carruth06207f62011-05-01 07:49:26 +00003025 DimExpr, RParen,
Chandler Carruthaf5a3c62011-05-01 08:48:21 +00003026 Context.getSizeType()));
John Wiegley21ff2e52011-04-28 00:16:57 +00003027}
3028
John Wiegley55262202011-04-25 06:54:41 +00003029ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET,
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003030 SourceLocation KWLoc,
3031 Expr *Queried,
3032 SourceLocation RParen) {
John Wiegley55262202011-04-25 06:54:41 +00003033 // If error parsing the expression, ignore.
3034 if (!Queried)
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003035 return ExprError();
John Wiegley55262202011-04-25 06:54:41 +00003036
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003037 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
John Wiegley55262202011-04-25 06:54:41 +00003038
3039 return move(Result);
3040}
3041
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003042static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
3043 switch (ET) {
3044 case ET_IsLValueExpr: return E->isLValue();
3045 case ET_IsRValueExpr: return E->isRValue();
3046 }
3047 llvm_unreachable("Expression trait not covered by switch");
3048}
3049
John Wiegley55262202011-04-25 06:54:41 +00003050ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003051 SourceLocation KWLoc,
3052 Expr *Queried,
3053 SourceLocation RParen) {
John Wiegley55262202011-04-25 06:54:41 +00003054 if (Queried->isTypeDependent()) {
3055 // Delay type-checking for type-dependent expressions.
3056 } else if (Queried->getType()->isPlaceholderType()) {
3057 ExprResult PE = CheckPlaceholderExpr(Queried);
3058 if (PE.isInvalid()) return ExprError();
3059 return BuildExpressionTrait(ET, KWLoc, PE.take(), RParen);
3060 }
3061
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003062 bool Value = EvaluateExpressionTrait(ET, Queried);
Chandler Carruthf7ef0002011-05-01 08:48:19 +00003063
Chandler Carruth4aa0af32011-05-01 07:44:20 +00003064 return Owned(new (Context) ExpressionTraitExpr(KWLoc, ET, Queried, Value,
3065 RParen, Context.BoolTy));
John Wiegley55262202011-04-25 06:54:41 +00003066}
3067
John Wiegley429bb272011-04-08 18:41:53 +00003068QualType Sema::CheckPointerToMemberOperands(ExprResult &lex, ExprResult &rex,
John McCallf89e55a2010-11-18 06:31:45 +00003069 ExprValueKind &VK,
3070 SourceLocation Loc,
3071 bool isIndirect) {
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003072 const char *OpSpelling = isIndirect ? "->*" : ".*";
3073 // C++ 5.5p2
3074 // The binary operator .* [p3: ->*] binds its second operand, which shall
3075 // be of type "pointer to member of T" (where T is a completely-defined
3076 // class type) [...]
John Wiegley429bb272011-04-08 18:41:53 +00003077 QualType RType = rex.get()->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003078 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
Douglas Gregore7450f52009-03-24 19:52:54 +00003079 if (!MemPtr) {
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003080 Diag(Loc, diag::err_bad_memptr_rhs)
John Wiegley429bb272011-04-08 18:41:53 +00003081 << OpSpelling << RType << rex.get()->getSourceRange();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003082 return QualType();
Mike Stump1eb44332009-09-09 15:08:12 +00003083 }
Douglas Gregore7450f52009-03-24 19:52:54 +00003084
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003085 QualType Class(MemPtr->getClass(), 0);
3086
Douglas Gregor7d520ba2010-10-13 20:41:14 +00003087 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
3088 // member pointer points must be completely-defined. However, there is no
3089 // reason for this semantic distinction, and the rule is not enforced by
3090 // other compilers. Therefore, we do not check this property, as it is
3091 // likely to be considered a defect.
Sebastian Redl59fc2692010-04-10 10:14:54 +00003092
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003093 // C++ 5.5p2
3094 // [...] to its first operand, which shall be of class T or of a class of
3095 // which T is an unambiguous and accessible base class. [p3: a pointer to
3096 // such a class]
John Wiegley429bb272011-04-08 18:41:53 +00003097 QualType LType = lex.get()->getType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003098 if (isIndirect) {
Ted Kremenek6217b802009-07-29 21:53:49 +00003099 if (const PointerType *Ptr = LType->getAs<PointerType>())
John McCallf89e55a2010-11-18 06:31:45 +00003100 LType = Ptr->getPointeeType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003101 else {
3102 Diag(Loc, diag::err_bad_memptr_lhs)
Fariborz Jahanianef78ac62009-10-26 20:45:27 +00003103 << OpSpelling << 1 << LType
Douglas Gregor849b2432010-03-31 17:46:05 +00003104 << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003105 return QualType();
3106 }
3107 }
3108
Douglas Gregora4923eb2009-11-16 21:35:15 +00003109 if (!Context.hasSameUnqualifiedType(Class, LType)) {
Sebastian Redl17e1d352010-04-23 17:18:26 +00003110 // If we want to check the hierarchy, we need a complete type.
3111 if (RequireCompleteType(Loc, LType, PDiag(diag::err_bad_memptr_lhs)
3112 << OpSpelling << (int)isIndirect)) {
3113 return QualType();
3114 }
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00003115 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
Douglas Gregora8f32e02009-10-06 17:59:45 +00003116 /*DetectVirtual=*/false);
Mike Stump390b4cc2009-05-16 07:39:55 +00003117 // FIXME: Would it be useful to print full ambiguity paths, or is that
3118 // overkill?
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003119 if (!IsDerivedFrom(LType, Class, Paths) ||
3120 Paths.isAmbiguous(Context.getCanonicalType(Class))) {
3121 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
John Wiegley429bb272011-04-08 18:41:53 +00003122 << (int)isIndirect << lex.get()->getType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003123 return QualType();
3124 }
Eli Friedman3005efe2010-01-16 00:00:48 +00003125 // Cast LHS to type of use.
3126 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
John McCall5baba9d2010-08-25 10:28:54 +00003127 ExprValueKind VK =
John Wiegley429bb272011-04-08 18:41:53 +00003128 isIndirect ? VK_RValue : CastCategory(lex.get());
Sebastian Redl906082e2010-07-20 04:20:21 +00003129
John McCallf871d0c2010-08-07 06:22:56 +00003130 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00003131 BuildBasePathArray(Paths, BasePath);
John Wiegley429bb272011-04-08 18:41:53 +00003132 lex = ImpCastExprToType(lex.take(), UseType, CK_DerivedToBase, VK, &BasePath);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003133 }
3134
John Wiegley429bb272011-04-08 18:41:53 +00003135 if (isa<CXXScalarValueInitExpr>(rex.get()->IgnoreParens())) {
Fariborz Jahanian05ebda92009-11-18 21:54:48 +00003136 // Diagnose use of pointer-to-member type which when used as
3137 // the functional cast in a pointer-to-member expression.
3138 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
3139 return QualType();
3140 }
John McCallf89e55a2010-11-18 06:31:45 +00003141
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003142 // C++ 5.5p2
3143 // The result is an object or a function of the type specified by the
3144 // second operand.
3145 // The cv qualifiers are the union of those in the pointer and the left side,
3146 // in accordance with 5.5p5 and 5.2.5.
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003147 QualType Result = MemPtr->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00003148 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers());
John McCallf89e55a2010-11-18 06:31:45 +00003149
Douglas Gregor6b4df912011-01-26 16:40:18 +00003150 // C++0x [expr.mptr.oper]p6:
3151 // In a .* expression whose object expression is an rvalue, the program is
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003152 // ill-formed if the second operand is a pointer to member function with
3153 // ref-qualifier &. In a ->* expression or in a .* expression whose object
3154 // expression is an lvalue, the program is ill-formed if the second operand
Douglas Gregor6b4df912011-01-26 16:40:18 +00003155 // is a pointer to member function with ref-qualifier &&.
3156 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
3157 switch (Proto->getRefQualifier()) {
3158 case RQ_None:
3159 // Do nothing
3160 break;
3161
3162 case RQ_LValue:
John Wiegley429bb272011-04-08 18:41:53 +00003163 if (!isIndirect && !lex.get()->Classify(Context).isLValue())
Douglas Gregor6b4df912011-01-26 16:40:18 +00003164 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
John Wiegley429bb272011-04-08 18:41:53 +00003165 << RType << 1 << lex.get()->getSourceRange();
Douglas Gregor6b4df912011-01-26 16:40:18 +00003166 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003167
Douglas Gregor6b4df912011-01-26 16:40:18 +00003168 case RQ_RValue:
John Wiegley429bb272011-04-08 18:41:53 +00003169 if (isIndirect || !lex.get()->Classify(Context).isRValue())
Douglas Gregor6b4df912011-01-26 16:40:18 +00003170 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
John Wiegley429bb272011-04-08 18:41:53 +00003171 << RType << 0 << lex.get()->getSourceRange();
Douglas Gregor6b4df912011-01-26 16:40:18 +00003172 break;
3173 }
3174 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003175
John McCallf89e55a2010-11-18 06:31:45 +00003176 // C++ [expr.mptr.oper]p6:
3177 // The result of a .* expression whose second operand is a pointer
3178 // to a data member is of the same value category as its
3179 // first operand. The result of a .* expression whose second
3180 // operand is a pointer to a member function is a prvalue. The
3181 // result of an ->* expression is an lvalue if its second operand
3182 // is a pointer to data member and a prvalue otherwise.
John McCall864c0412011-04-26 20:42:42 +00003183 if (Result->isFunctionType()) {
John McCallf89e55a2010-11-18 06:31:45 +00003184 VK = VK_RValue;
John McCall864c0412011-04-26 20:42:42 +00003185 return Context.BoundMemberTy;
3186 } else if (isIndirect) {
John McCallf89e55a2010-11-18 06:31:45 +00003187 VK = VK_LValue;
John McCall864c0412011-04-26 20:42:42 +00003188 } else {
John Wiegley429bb272011-04-08 18:41:53 +00003189 VK = lex.get()->getValueKind();
John McCall864c0412011-04-26 20:42:42 +00003190 }
John McCallf89e55a2010-11-18 06:31:45 +00003191
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003192 return Result;
3193}
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003194
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003195/// \brief Try to convert a type to another according to C++0x 5.16p3.
3196///
3197/// This is part of the parameter validation for the ? operator. If either
3198/// value operand is a class type, the two operands are attempted to be
3199/// converted to each other. This function does the conversion in one direction.
Douglas Gregorb70cf442010-03-26 20:14:36 +00003200/// It returns true if the program is ill-formed and has already been diagnosed
3201/// as such.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003202static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
3203 SourceLocation QuestionLoc,
Douglas Gregorb70cf442010-03-26 20:14:36 +00003204 bool &HaveConversion,
3205 QualType &ToType) {
3206 HaveConversion = false;
3207 ToType = To->getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003208
3209 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
Douglas Gregorb70cf442010-03-26 20:14:36 +00003210 SourceLocation());
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003211 // C++0x 5.16p3
3212 // The process for determining whether an operand expression E1 of type T1
3213 // can be converted to match an operand expression E2 of type T2 is defined
3214 // as follows:
3215 // -- If E2 is an lvalue:
John McCall7eb0a9e2010-11-24 05:12:34 +00003216 bool ToIsLvalue = To->isLValue();
Douglas Gregor0fd8ff72010-03-26 20:59:55 +00003217 if (ToIsLvalue) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003218 // E1 can be converted to match E2 if E1 can be implicitly converted to
3219 // type "lvalue reference to T2", subject to the constraint that in the
3220 // conversion the reference must bind directly to E1.
Douglas Gregorb70cf442010-03-26 20:14:36 +00003221 QualType T = Self.Context.getLValueReferenceType(ToType);
3222 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003223
Douglas Gregorb70cf442010-03-26 20:14:36 +00003224 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
3225 if (InitSeq.isDirectReferenceBinding()) {
3226 ToType = T;
3227 HaveConversion = true;
3228 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003229 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003230
Douglas Gregorb70cf442010-03-26 20:14:36 +00003231 if (InitSeq.isAmbiguous())
3232 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003233 }
John McCallb1bdc622010-02-25 01:37:24 +00003234
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003235 // -- If E2 is an rvalue, or if the conversion above cannot be done:
3236 // -- if E1 and E2 have class type, and the underlying class types are
3237 // the same or one is a base class of the other:
3238 QualType FTy = From->getType();
3239 QualType TTy = To->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003240 const RecordType *FRec = FTy->getAs<RecordType>();
3241 const RecordType *TRec = TTy->getAs<RecordType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003242 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
Douglas Gregorb70cf442010-03-26 20:14:36 +00003243 Self.IsDerivedFrom(FTy, TTy);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003244 if (FRec && TRec &&
Douglas Gregorb70cf442010-03-26 20:14:36 +00003245 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003246 // E1 can be converted to match E2 if the class of T2 is the
3247 // same type as, or a base class of, the class of T1, and
3248 // [cv2 > cv1].
John McCallb1bdc622010-02-25 01:37:24 +00003249 if (FRec == TRec || FDerivedFromT) {
3250 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00003251 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
3252 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
Sebastian Redl383616c2011-06-05 12:23:28 +00003253 if (InitSeq) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00003254 HaveConversion = true;
3255 return false;
3256 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003257
Douglas Gregorb70cf442010-03-26 20:14:36 +00003258 if (InitSeq.isAmbiguous())
3259 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003260 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003261 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003262
Douglas Gregorb70cf442010-03-26 20:14:36 +00003263 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003264 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003265
Douglas Gregorb70cf442010-03-26 20:14:36 +00003266 // -- Otherwise: E1 can be converted to match E2 if E1 can be
3267 // implicitly converted to the type that expression E2 would have
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003268 // if E2 were converted to an rvalue (or the type it has, if E2 is
Douglas Gregor0fd8ff72010-03-26 20:59:55 +00003269 // an rvalue).
3270 //
3271 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
3272 // to the array-to-pointer or function-to-pointer conversions.
3273 if (!TTy->getAs<TagType>())
3274 TTy = TTy.getUnqualifiedType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003275
Douglas Gregorb70cf442010-03-26 20:14:36 +00003276 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
3277 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
Sebastian Redl383616c2011-06-05 12:23:28 +00003278 HaveConversion = !InitSeq.Failed();
Douglas Gregorb70cf442010-03-26 20:14:36 +00003279 ToType = TTy;
3280 if (InitSeq.isAmbiguous())
3281 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
3282
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003283 return false;
3284}
3285
3286/// \brief Try to find a common type for two according to C++0x 5.16p5.
3287///
3288/// This is part of the parameter validation for the ? operator. If either
3289/// value operand is a class type, overload resolution is used to find a
3290/// conversion to a common type.
John Wiegley429bb272011-04-08 18:41:53 +00003291static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
Chandler Carruth82214a82011-02-18 23:54:50 +00003292 SourceLocation QuestionLoc) {
John Wiegley429bb272011-04-08 18:41:53 +00003293 Expr *Args[2] = { LHS.get(), RHS.get() };
Chandler Carruth82214a82011-02-18 23:54:50 +00003294 OverloadCandidateSet CandidateSet(QuestionLoc);
3295 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args, 2,
3296 CandidateSet);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003297
3298 OverloadCandidateSet::iterator Best;
Chandler Carruth82214a82011-02-18 23:54:50 +00003299 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
John Wiegley429bb272011-04-08 18:41:53 +00003300 case OR_Success: {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003301 // We found a match. Perform the conversions on the arguments and move on.
John Wiegley429bb272011-04-08 18:41:53 +00003302 ExprResult LHSRes =
3303 Self.PerformImplicitConversion(LHS.get(), Best->BuiltinTypes.ParamTypes[0],
3304 Best->Conversions[0], Sema::AA_Converting);
3305 if (LHSRes.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003306 break;
John Wiegley429bb272011-04-08 18:41:53 +00003307 LHS = move(LHSRes);
3308
3309 ExprResult RHSRes =
3310 Self.PerformImplicitConversion(RHS.get(), Best->BuiltinTypes.ParamTypes[1],
3311 Best->Conversions[1], Sema::AA_Converting);
3312 if (RHSRes.isInvalid())
3313 break;
3314 RHS = move(RHSRes);
Chandler Carruth25ca4212011-02-25 19:41:05 +00003315 if (Best->Function)
3316 Self.MarkDeclarationReferenced(QuestionLoc, Best->Function);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003317 return false;
John Wiegley429bb272011-04-08 18:41:53 +00003318 }
3319
Douglas Gregor20093b42009-12-09 23:02:17 +00003320 case OR_No_Viable_Function:
Chandler Carruth82214a82011-02-18 23:54:50 +00003321
3322 // Emit a better diagnostic if one of the expressions is a null pointer
3323 // constant and the other is a pointer type. In this case, the user most
3324 // likely forgot to take the address of the other expression.
John Wiegley429bb272011-04-08 18:41:53 +00003325 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carruth82214a82011-02-18 23:54:50 +00003326 return true;
3327
3328 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley429bb272011-04-08 18:41:53 +00003329 << LHS.get()->getType() << RHS.get()->getType()
3330 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003331 return true;
3332
Douglas Gregor20093b42009-12-09 23:02:17 +00003333 case OR_Ambiguous:
Chandler Carruth82214a82011-02-18 23:54:50 +00003334 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
John Wiegley429bb272011-04-08 18:41:53 +00003335 << LHS.get()->getType() << RHS.get()->getType()
3336 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Mike Stump390b4cc2009-05-16 07:39:55 +00003337 // FIXME: Print the possible common types by printing the return types of
3338 // the viable candidates.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003339 break;
3340
Douglas Gregor20093b42009-12-09 23:02:17 +00003341 case OR_Deleted:
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003342 assert(false && "Conditional operator has only built-in overloads");
3343 break;
3344 }
3345 return true;
3346}
3347
Sebastian Redl76458502009-04-17 16:30:52 +00003348/// \brief Perform an "extended" implicit conversion as returned by
3349/// TryClassUnification.
John Wiegley429bb272011-04-08 18:41:53 +00003350static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00003351 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
John Wiegley429bb272011-04-08 18:41:53 +00003352 InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(),
Douglas Gregorb70cf442010-03-26 20:14:36 +00003353 SourceLocation());
John Wiegley429bb272011-04-08 18:41:53 +00003354 Expr *Arg = E.take();
3355 InitializationSequence InitSeq(Self, Entity, Kind, &Arg, 1);
3356 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, MultiExprArg(&Arg, 1));
Douglas Gregorb70cf442010-03-26 20:14:36 +00003357 if (Result.isInvalid())
Sebastian Redl76458502009-04-17 16:30:52 +00003358 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003359
John Wiegley429bb272011-04-08 18:41:53 +00003360 E = Result;
Sebastian Redl76458502009-04-17 16:30:52 +00003361 return false;
3362}
3363
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003364/// \brief Check the operands of ?: under C++ semantics.
3365///
3366/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
3367/// extension. In this case, LHS == Cond. (But they're not aliases.)
John Wiegley429bb272011-04-08 18:41:53 +00003368QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
John McCall56ca35d2011-02-17 10:25:35 +00003369 ExprValueKind &VK, ExprObjectKind &OK,
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003370 SourceLocation QuestionLoc) {
Mike Stump390b4cc2009-05-16 07:39:55 +00003371 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
3372 // interface pointers.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003373
3374 // C++0x 5.16p1
3375 // The first expression is contextually converted to bool.
John Wiegley429bb272011-04-08 18:41:53 +00003376 if (!Cond.get()->isTypeDependent()) {
3377 ExprResult CondRes = CheckCXXBooleanCondition(Cond.take());
3378 if (CondRes.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003379 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00003380 Cond = move(CondRes);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003381 }
3382
John McCallf89e55a2010-11-18 06:31:45 +00003383 // Assume r-value.
3384 VK = VK_RValue;
John McCall09431682010-11-18 19:01:18 +00003385 OK = OK_Ordinary;
John McCallf89e55a2010-11-18 06:31:45 +00003386
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003387 // Either of the arguments dependent?
John Wiegley429bb272011-04-08 18:41:53 +00003388 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003389 return Context.DependentTy;
3390
3391 // C++0x 5.16p2
3392 // If either the second or the third operand has type (cv) void, ...
John Wiegley429bb272011-04-08 18:41:53 +00003393 QualType LTy = LHS.get()->getType();
3394 QualType RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003395 bool LVoid = LTy->isVoidType();
3396 bool RVoid = RTy->isVoidType();
3397 if (LVoid || RVoid) {
3398 // ... then the [l2r] conversions are performed on the second and third
3399 // operands ...
John Wiegley429bb272011-04-08 18:41:53 +00003400 LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
3401 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
3402 if (LHS.isInvalid() || RHS.isInvalid())
3403 return QualType();
3404 LTy = LHS.get()->getType();
3405 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003406
3407 // ... and one of the following shall hold:
3408 // -- The second or the third operand (but not both) is a throw-
3409 // expression; the result is of the type of the other and is an rvalue.
John Wiegley429bb272011-04-08 18:41:53 +00003410 bool LThrow = isa<CXXThrowExpr>(LHS.get());
3411 bool RThrow = isa<CXXThrowExpr>(RHS.get());
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003412 if (LThrow && !RThrow)
3413 return RTy;
3414 if (RThrow && !LThrow)
3415 return LTy;
3416
3417 // -- Both the second and third operands have type void; the result is of
3418 // type void and is an rvalue.
3419 if (LVoid && RVoid)
3420 return Context.VoidTy;
3421
3422 // Neither holds, error.
3423 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
3424 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
John Wiegley429bb272011-04-08 18:41:53 +00003425 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003426 return QualType();
3427 }
3428
3429 // Neither is void.
3430
3431 // C++0x 5.16p3
3432 // Otherwise, if the second and third operand have different types, and
3433 // either has (cv) class type, and attempt is made to convert each of those
3434 // operands to the other.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003435 if (!Context.hasSameType(LTy, RTy) &&
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003436 (LTy->isRecordType() || RTy->isRecordType())) {
3437 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
3438 // These return true if a single direction is already ambiguous.
Douglas Gregorb70cf442010-03-26 20:14:36 +00003439 QualType L2RType, R2LType;
3440 bool HaveL2R, HaveR2L;
John Wiegley429bb272011-04-08 18:41:53 +00003441 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003442 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00003443 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003444 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003445
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003446 // If both can be converted, [...] the program is ill-formed.
3447 if (HaveL2R && HaveR2L) {
3448 Diag(QuestionLoc, diag::err_conditional_ambiguous)
John Wiegley429bb272011-04-08 18:41:53 +00003449 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003450 return QualType();
3451 }
3452
3453 // If exactly one conversion is possible, that conversion is applied to
3454 // the chosen operand and the converted operands are used in place of the
3455 // original operands for the remainder of this section.
3456 if (HaveL2R) {
John Wiegley429bb272011-04-08 18:41:53 +00003457 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003458 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00003459 LTy = LHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003460 } else if (HaveR2L) {
John Wiegley429bb272011-04-08 18:41:53 +00003461 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003462 return QualType();
John Wiegley429bb272011-04-08 18:41:53 +00003463 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003464 }
3465 }
3466
3467 // C++0x 5.16p4
John McCallf89e55a2010-11-18 06:31:45 +00003468 // If the second and third operands are glvalues of the same value
3469 // category and have the same type, the result is of that type and
3470 // value category and it is a bit-field if the second or the third
3471 // operand is a bit-field, or if both are bit-fields.
John McCall09431682010-11-18 19:01:18 +00003472 // We only extend this to bitfields, not to the crazy other kinds of
3473 // l-values.
Douglas Gregor1927b1f2010-04-01 22:47:07 +00003474 bool Same = Context.hasSameType(LTy, RTy);
John McCallf89e55a2010-11-18 06:31:45 +00003475 if (Same &&
John Wiegley429bb272011-04-08 18:41:53 +00003476 LHS.get()->isGLValue() &&
3477 LHS.get()->getValueKind() == RHS.get()->getValueKind() &&
3478 LHS.get()->isOrdinaryOrBitFieldObject() &&
3479 RHS.get()->isOrdinaryOrBitFieldObject()) {
3480 VK = LHS.get()->getValueKind();
3481 if (LHS.get()->getObjectKind() == OK_BitField ||
3482 RHS.get()->getObjectKind() == OK_BitField)
John McCall09431682010-11-18 19:01:18 +00003483 OK = OK_BitField;
John McCallf89e55a2010-11-18 06:31:45 +00003484 return LTy;
Fariborz Jahanian3911a1a2010-09-25 01:08:05 +00003485 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003486
3487 // C++0x 5.16p5
3488 // Otherwise, the result is an rvalue. If the second and third operands
3489 // do not have the same type, and either has (cv) class type, ...
3490 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
3491 // ... overload resolution is used to determine the conversions (if any)
3492 // to be applied to the operands. If the overload resolution fails, the
3493 // program is ill-formed.
3494 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
3495 return QualType();
3496 }
3497
3498 // C++0x 5.16p6
3499 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
3500 // conversions are performed on the second and third operands.
John Wiegley429bb272011-04-08 18:41:53 +00003501 LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
3502 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
3503 if (LHS.isInvalid() || RHS.isInvalid())
3504 return QualType();
3505 LTy = LHS.get()->getType();
3506 RTy = RHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003507
3508 // After those conversions, one of the following shall hold:
3509 // -- The second and third operands have the same type; the result
Douglas Gregorb65a4582010-05-19 23:40:50 +00003510 // is of that type. If the operands have class type, the result
3511 // is a prvalue temporary of the result type, which is
3512 // copy-initialized from either the second operand or the third
3513 // operand depending on the value of the first operand.
3514 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
3515 if (LTy->isRecordType()) {
3516 // The operands have class type. Make a temporary copy.
3517 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003518 ExprResult LHSCopy = PerformCopyInitialization(Entity,
3519 SourceLocation(),
John Wiegley429bb272011-04-08 18:41:53 +00003520 LHS);
Douglas Gregorb65a4582010-05-19 23:40:50 +00003521 if (LHSCopy.isInvalid())
3522 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003523
3524 ExprResult RHSCopy = PerformCopyInitialization(Entity,
3525 SourceLocation(),
John Wiegley429bb272011-04-08 18:41:53 +00003526 RHS);
Douglas Gregorb65a4582010-05-19 23:40:50 +00003527 if (RHSCopy.isInvalid())
3528 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003529
John Wiegley429bb272011-04-08 18:41:53 +00003530 LHS = LHSCopy;
3531 RHS = RHSCopy;
Douglas Gregorb65a4582010-05-19 23:40:50 +00003532 }
3533
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003534 return LTy;
Douglas Gregorb65a4582010-05-19 23:40:50 +00003535 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003536
Douglas Gregorfb4a5432010-05-18 22:42:18 +00003537 // Extension: conditional operator involving vector types.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003538 if (LTy->isVectorType() || RTy->isVectorType())
Douglas Gregorfb4a5432010-05-18 22:42:18 +00003539 return CheckVectorOperands(QuestionLoc, LHS, RHS);
3540
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003541 // -- The second and third operands have arithmetic or enumeration type;
3542 // the usual arithmetic conversions are performed to bring them to a
3543 // common type, and the result is of that type.
3544 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
3545 UsualArithmeticConversions(LHS, RHS);
John Wiegley429bb272011-04-08 18:41:53 +00003546 if (LHS.isInvalid() || RHS.isInvalid())
3547 return QualType();
3548 return LHS.get()->getType();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003549 }
3550
3551 // -- The second and third operands have pointer type, or one has pointer
3552 // type and the other is a null pointer constant; pointer conversions
3553 // and qualification conversions are performed to bring them to their
3554 // composite pointer type. The result is of the composite pointer type.
Eli Friedmande8ac492010-01-02 22:56:07 +00003555 // -- The second and third operands have pointer to member type, or one has
3556 // pointer to member type and the other is a null pointer constant;
3557 // pointer to member conversions and qualification conversions are
3558 // performed to bring them to a common type, whose cv-qualification
3559 // shall match the cv-qualification of either the second or the third
3560 // operand. The result is of the common type.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003561 bool NonStandardCompositeType = false;
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003562 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003563 isSFINAEContext()? 0 : &NonStandardCompositeType);
3564 if (!Composite.isNull()) {
3565 if (NonStandardCompositeType)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003566 Diag(QuestionLoc,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003567 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
3568 << LTy << RTy << Composite
John Wiegley429bb272011-04-08 18:41:53 +00003569 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003570
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003571 return Composite;
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003572 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003573
Douglas Gregor1927b1f2010-04-01 22:47:07 +00003574 // Similarly, attempt to find composite type of two objective-c pointers.
Fariborz Jahanian55016362009-12-10 20:46:08 +00003575 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
3576 if (!Composite.isNull())
3577 return Composite;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003578
Chandler Carruth7ef93242011-02-19 00:13:59 +00003579 // Check if we are using a null with a non-pointer type.
John Wiegley429bb272011-04-08 18:41:53 +00003580 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carruth7ef93242011-02-19 00:13:59 +00003581 return QualType();
3582
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003583 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
John Wiegley429bb272011-04-08 18:41:53 +00003584 << LHS.get()->getType() << RHS.get()->getType()
3585 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003586 return QualType();
3587}
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003588
3589/// \brief Find a merged pointer type and convert the two expressions to it.
3590///
Douglas Gregor20b3e992009-08-24 17:42:35 +00003591/// This finds the composite pointer type (or member pointer type) for @p E1
3592/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this
3593/// type and returns it.
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003594/// It does not emit diagnostics.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003595///
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003596/// \param Loc The location of the operator requiring these two expressions to
3597/// be converted to the composite pointer type.
3598///
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003599/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
3600/// a non-standard (but still sane) composite type to which both expressions
3601/// can be converted. When such a type is chosen, \c *NonStandardCompositeType
3602/// will be set true.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003603QualType Sema::FindCompositePointerType(SourceLocation Loc,
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003604 Expr *&E1, Expr *&E2,
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003605 bool *NonStandardCompositeType) {
3606 if (NonStandardCompositeType)
3607 *NonStandardCompositeType = false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003608
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003609 assert(getLangOptions().CPlusPlus && "This function assumes C++");
3610 QualType T1 = E1->getType(), T2 = E2->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003611
Fariborz Jahanian0cedfbd2009-12-08 20:04:24 +00003612 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
3613 !T2->isAnyPointerType() && !T2->isMemberPointerType())
Douglas Gregor20b3e992009-08-24 17:42:35 +00003614 return QualType();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003615
3616 // C++0x 5.9p2
3617 // Pointer conversions and qualification conversions are performed on
3618 // pointer operands to bring them to their composite pointer type. If
3619 // one operand is a null pointer constant, the composite pointer type is
3620 // the type of the other operand.
Douglas Gregorce940492009-09-25 04:25:58 +00003621 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003622 if (T2->isMemberPointerType())
John Wiegley429bb272011-04-08 18:41:53 +00003623 E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003624 else
John Wiegley429bb272011-04-08 18:41:53 +00003625 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003626 return T2;
3627 }
Douglas Gregorce940492009-09-25 04:25:58 +00003628 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003629 if (T1->isMemberPointerType())
John Wiegley429bb272011-04-08 18:41:53 +00003630 E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).take();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003631 else
John Wiegley429bb272011-04-08 18:41:53 +00003632 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003633 return T1;
3634 }
Mike Stump1eb44332009-09-09 15:08:12 +00003635
Douglas Gregor20b3e992009-08-24 17:42:35 +00003636 // Now both have to be pointers or member pointers.
Sebastian Redla439e6f2009-11-16 21:03:45 +00003637 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
3638 (!T2->isPointerType() && !T2->isMemberPointerType()))
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003639 return QualType();
3640
3641 // Otherwise, of one of the operands has type "pointer to cv1 void," then
3642 // the other has type "pointer to cv2 T" and the composite pointer type is
3643 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
3644 // Otherwise, the composite pointer type is a pointer type similar to the
3645 // type of one of the operands, with a cv-qualification signature that is
3646 // the union of the cv-qualification signatures of the operand types.
3647 // In practice, the first part here is redundant; it's subsumed by the second.
3648 // What we do here is, we build the two possible composite types, and try the
3649 // conversions in both directions. If only one works, or if the two composite
3650 // types are the same, we have succeeded.
John McCall0953e762009-09-24 19:53:00 +00003651 // FIXME: extended qualifiers?
Sebastian Redla439e6f2009-11-16 21:03:45 +00003652 typedef llvm::SmallVector<unsigned, 4> QualifierVector;
3653 QualifierVector QualifierUnion;
3654 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4>
3655 ContainingClassVector;
3656 ContainingClassVector MemberOfClass;
3657 QualType Composite1 = Context.getCanonicalType(T1),
3658 Composite2 = Context.getCanonicalType(T2);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003659 unsigned NeedConstBefore = 0;
Douglas Gregor20b3e992009-08-24 17:42:35 +00003660 do {
3661 const PointerType *Ptr1, *Ptr2;
3662 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
3663 (Ptr2 = Composite2->getAs<PointerType>())) {
3664 Composite1 = Ptr1->getPointeeType();
3665 Composite2 = Ptr2->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003666
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003667 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003668 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003669 if (NonStandardCompositeType &&
3670 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
3671 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003672
Douglas Gregor20b3e992009-08-24 17:42:35 +00003673 QualifierUnion.push_back(
3674 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
3675 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0));
3676 continue;
3677 }
Mike Stump1eb44332009-09-09 15:08:12 +00003678
Douglas Gregor20b3e992009-08-24 17:42:35 +00003679 const MemberPointerType *MemPtr1, *MemPtr2;
3680 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
3681 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
3682 Composite1 = MemPtr1->getPointeeType();
3683 Composite2 = MemPtr2->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003684
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003685 // If we're allowed to create a non-standard composite type, keep track
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003686 // of where we need to fill in additional 'const' qualifiers.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003687 if (NonStandardCompositeType &&
3688 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
3689 NeedConstBefore = QualifierUnion.size();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003690
Douglas Gregor20b3e992009-08-24 17:42:35 +00003691 QualifierUnion.push_back(
3692 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
3693 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
3694 MemPtr2->getClass()));
3695 continue;
3696 }
Mike Stump1eb44332009-09-09 15:08:12 +00003697
Douglas Gregor20b3e992009-08-24 17:42:35 +00003698 // FIXME: block pointer types?
Mike Stump1eb44332009-09-09 15:08:12 +00003699
Douglas Gregor20b3e992009-08-24 17:42:35 +00003700 // Cannot unwrap any more types.
3701 break;
3702 } while (true);
Mike Stump1eb44332009-09-09 15:08:12 +00003703
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003704 if (NeedConstBefore && NonStandardCompositeType) {
3705 // Extension: Add 'const' to qualifiers that come before the first qualifier
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003706 // mismatch, so that our (non-standard!) composite type meets the
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00003707 // requirements of C++ [conv.qual]p4 bullet 3.
3708 for (unsigned I = 0; I != NeedConstBefore; ++I) {
3709 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
3710 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
3711 *NonStandardCompositeType = true;
3712 }
3713 }
3714 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003715
Douglas Gregor20b3e992009-08-24 17:42:35 +00003716 // Rewrap the composites as pointers or member pointers with the union CVRs.
Sebastian Redla439e6f2009-11-16 21:03:45 +00003717 ContainingClassVector::reverse_iterator MOC
3718 = MemberOfClass.rbegin();
3719 for (QualifierVector::reverse_iterator
3720 I = QualifierUnion.rbegin(),
3721 E = QualifierUnion.rend();
Douglas Gregor20b3e992009-08-24 17:42:35 +00003722 I != E; (void)++I, ++MOC) {
John McCall0953e762009-09-24 19:53:00 +00003723 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
Douglas Gregor20b3e992009-08-24 17:42:35 +00003724 if (MOC->first && MOC->second) {
3725 // Rebuild member pointer type
John McCall0953e762009-09-24 19:53:00 +00003726 Composite1 = Context.getMemberPointerType(
3727 Context.getQualifiedType(Composite1, Quals),
3728 MOC->first);
3729 Composite2 = Context.getMemberPointerType(
3730 Context.getQualifiedType(Composite2, Quals),
3731 MOC->second);
Douglas Gregor20b3e992009-08-24 17:42:35 +00003732 } else {
3733 // Rebuild pointer type
John McCall0953e762009-09-24 19:53:00 +00003734 Composite1
3735 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
3736 Composite2
3737 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
Douglas Gregor20b3e992009-08-24 17:42:35 +00003738 }
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003739 }
3740
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003741 // Try to convert to the first composite pointer type.
3742 InitializedEntity Entity1
3743 = InitializedEntity::InitializeTemporary(Composite1);
3744 InitializationKind Kind
3745 = InitializationKind::CreateCopy(Loc, SourceLocation());
3746 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1);
3747 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1);
Mike Stump1eb44332009-09-09 15:08:12 +00003748
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003749 if (E1ToC1 && E2ToC1) {
3750 // Conversion to Composite1 is viable.
3751 if (!Context.hasSameType(Composite1, Composite2)) {
3752 // Composite2 is a different type from Composite1. Check whether
3753 // Composite2 is also viable.
3754 InitializedEntity Entity2
3755 = InitializedEntity::InitializeTemporary(Composite2);
3756 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1);
3757 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1);
3758 if (E1ToC2 && E2ToC2) {
3759 // Both Composite1 and Composite2 are viable and are different;
3760 // this is an ambiguity.
3761 return QualType();
3762 }
3763 }
3764
3765 // Convert E1 to Composite1
John McCall60d7b3a2010-08-24 06:29:42 +00003766 ExprResult E1Result
John McCallca0408f2010-08-23 06:44:23 +00003767 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E1,1));
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003768 if (E1Result.isInvalid())
3769 return QualType();
3770 E1 = E1Result.takeAs<Expr>();
3771
3772 // Convert E2 to Composite1
John McCall60d7b3a2010-08-24 06:29:42 +00003773 ExprResult E2Result
John McCallca0408f2010-08-23 06:44:23 +00003774 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E2,1));
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003775 if (E2Result.isInvalid())
3776 return QualType();
3777 E2 = E2Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003778
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003779 return Composite1;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003780 }
3781
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003782 // Check whether Composite2 is viable.
3783 InitializedEntity Entity2
3784 = InitializedEntity::InitializeTemporary(Composite2);
3785 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1);
3786 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1);
3787 if (!E1ToC2 || !E2ToC2)
3788 return QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003789
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003790 // Convert E1 to Composite2
John McCall60d7b3a2010-08-24 06:29:42 +00003791 ExprResult E1Result
John McCallca0408f2010-08-23 06:44:23 +00003792 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E1, 1));
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003793 if (E1Result.isInvalid())
3794 return QualType();
3795 E1 = E1Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003796
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003797 // Convert E2 to Composite2
John McCall60d7b3a2010-08-24 06:29:42 +00003798 ExprResult E2Result
John McCallca0408f2010-08-23 06:44:23 +00003799 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E2, 1));
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003800 if (E2Result.isInvalid())
3801 return QualType();
3802 E2 = E2Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003803
Douglas Gregor8f00dcf2010-04-16 23:20:25 +00003804 return Composite2;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003805}
Anders Carlsson165a0a02009-05-17 18:41:29 +00003806
John McCall60d7b3a2010-08-24 06:29:42 +00003807ExprResult Sema::MaybeBindToTemporary(Expr *E) {
Douglas Gregor19cc1c72010-11-01 21:10:29 +00003808 if (!E)
3809 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003810
Anders Carlsson089c2602009-08-15 23:41:35 +00003811 if (!Context.getLangOptions().CPlusPlus)
3812 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +00003813
Douglas Gregor51326552009-12-24 18:51:59 +00003814 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
3815
Ted Kremenek6217b802009-07-29 21:53:49 +00003816 const RecordType *RT = E->getType()->getAs<RecordType>();
Anders Carlssondef11992009-05-30 20:36:53 +00003817 if (!RT)
3818 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +00003819
Douglas Gregor5e6fcd42011-02-08 02:14:35 +00003820 // If the result is a glvalue, we shouldn't bind it.
3821 if (E->Classify(Context).isGLValue())
3822 return Owned(E);
John McCall86ff3082010-02-04 22:26:26 +00003823
3824 // That should be enough to guarantee that this type is complete.
3825 // If it has a trivial destructor, we can avoid the extra copy.
Jeffrey Yasskinb7ee2e52011-01-27 19:17:54 +00003826 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
John McCall507384f2010-08-12 02:40:37 +00003827 if (RD->isInvalidDecl() || RD->hasTrivialDestructor())
John McCall86ff3082010-02-04 22:26:26 +00003828 return Owned(E);
3829
Douglas Gregordb89f282010-07-01 22:47:18 +00003830 CXXTemporary *Temp = CXXTemporary::Create(Context, LookupDestructor(RD));
Anders Carlsson860306e2009-05-30 21:21:49 +00003831 ExprTemporaries.push_back(Temp);
Douglas Gregordb89f282010-07-01 22:47:18 +00003832 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00003833 MarkDeclarationReferenced(E->getExprLoc(), Destructor);
John McCallc91cc662010-04-07 00:41:46 +00003834 CheckDestructorAccess(E->getExprLoc(), Destructor,
3835 PDiag(diag::err_access_dtor_temp)
3836 << E->getType());
3837 }
Anders Carlssondef11992009-05-30 20:36:53 +00003838 // FIXME: Add the temporary to the temporaries vector.
3839 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
3840}
3841
John McCall4765fa02010-12-06 08:20:24 +00003842Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
Anders Carlsson99ba36d2009-06-05 15:38:08 +00003843 assert(SubExpr && "sub expression can't be null!");
Mike Stump1eb44332009-09-09 15:08:12 +00003844
Douglas Gregor1f5f3a42009-12-03 17:10:37 +00003845 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
3846 assert(ExprTemporaries.size() >= FirstTemporary);
3847 if (ExprTemporaries.size() == FirstTemporary)
Anders Carlsson99ba36d2009-06-05 15:38:08 +00003848 return SubExpr;
Mike Stump1eb44332009-09-09 15:08:12 +00003849
John McCall4765fa02010-12-06 08:20:24 +00003850 Expr *E = ExprWithCleanups::Create(Context, SubExpr,
3851 &ExprTemporaries[FirstTemporary],
3852 ExprTemporaries.size() - FirstTemporary);
Douglas Gregor1f5f3a42009-12-03 17:10:37 +00003853 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
3854 ExprTemporaries.end());
Mike Stump1eb44332009-09-09 15:08:12 +00003855
Anders Carlsson99ba36d2009-06-05 15:38:08 +00003856 return E;
3857}
3858
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003859ExprResult
John McCall4765fa02010-12-06 08:20:24 +00003860Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) {
Douglas Gregor90f93822009-12-22 22:17:25 +00003861 if (SubExpr.isInvalid())
3862 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003863
John McCall4765fa02010-12-06 08:20:24 +00003864 return Owned(MaybeCreateExprWithCleanups(SubExpr.take()));
Douglas Gregor90f93822009-12-22 22:17:25 +00003865}
3866
John McCall4765fa02010-12-06 08:20:24 +00003867Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00003868 assert(SubStmt && "sub statement can't be null!");
3869
3870 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
3871 assert(ExprTemporaries.size() >= FirstTemporary);
3872 if (ExprTemporaries.size() == FirstTemporary)
3873 return SubStmt;
3874
3875 // FIXME: In order to attach the temporaries, wrap the statement into
3876 // a StmtExpr; currently this is only used for asm statements.
3877 // This is hacky, either create a new CXXStmtWithTemporaries statement or
3878 // a new AsmStmtWithTemporaries.
3879 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, &SubStmt, 1,
3880 SourceLocation(),
3881 SourceLocation());
3882 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
3883 SourceLocation());
John McCall4765fa02010-12-06 08:20:24 +00003884 return MaybeCreateExprWithCleanups(E);
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00003885}
3886
John McCall60d7b3a2010-08-24 06:29:42 +00003887ExprResult
John McCall9ae2f072010-08-23 23:25:46 +00003888Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc,
John McCallb3d87482010-08-24 05:47:05 +00003889 tok::TokenKind OpKind, ParsedType &ObjectType,
Douglas Gregord4dca082010-02-24 18:44:31 +00003890 bool &MayBePseudoDestructor) {
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003891 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCall60d7b3a2010-08-24 06:29:42 +00003892 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
John McCall9ae2f072010-08-23 23:25:46 +00003893 if (Result.isInvalid()) return ExprError();
3894 Base = Result.get();
Mike Stump1eb44332009-09-09 15:08:12 +00003895
John McCall9ae2f072010-08-23 23:25:46 +00003896 QualType BaseType = Base->getType();
Douglas Gregord4dca082010-02-24 18:44:31 +00003897 MayBePseudoDestructor = false;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003898 if (BaseType->isDependentType()) {
Douglas Gregor43d88632009-11-04 22:49:18 +00003899 // If we have a pointer to a dependent type and are using the -> operator,
3900 // the object type is the type that the pointer points to. We might still
3901 // have enough information about that type to do something useful.
3902 if (OpKind == tok::arrow)
3903 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3904 BaseType = Ptr->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003905
John McCallb3d87482010-08-24 05:47:05 +00003906 ObjectType = ParsedType::make(BaseType);
Douglas Gregord4dca082010-02-24 18:44:31 +00003907 MayBePseudoDestructor = true;
John McCall9ae2f072010-08-23 23:25:46 +00003908 return Owned(Base);
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003909 }
Mike Stump1eb44332009-09-09 15:08:12 +00003910
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003911 // C++ [over.match.oper]p8:
Mike Stump1eb44332009-09-09 15:08:12 +00003912 // [...] When operator->returns, the operator-> is applied to the value
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003913 // returned, with the original second operand.
3914 if (OpKind == tok::arrow) {
John McCallc4e83212009-09-30 01:01:30 +00003915 // The set of types we've considered so far.
John McCall432887f2009-09-30 01:30:54 +00003916 llvm::SmallPtrSet<CanQualType,8> CTypes;
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00003917 llvm::SmallVector<SourceLocation, 8> Locations;
John McCall432887f2009-09-30 01:30:54 +00003918 CTypes.insert(Context.getCanonicalType(BaseType));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003919
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003920 while (BaseType->isRecordType()) {
John McCall9ae2f072010-08-23 23:25:46 +00003921 Result = BuildOverloadedArrowExpr(S, Base, OpLoc);
3922 if (Result.isInvalid())
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003923 return ExprError();
John McCall9ae2f072010-08-23 23:25:46 +00003924 Base = Result.get();
3925 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
Anders Carlssonde699e52009-10-13 22:55:59 +00003926 Locations.push_back(OpCall->getDirectCallee()->getLocation());
John McCall9ae2f072010-08-23 23:25:46 +00003927 BaseType = Base->getType();
John McCallc4e83212009-09-30 01:01:30 +00003928 CanQualType CBaseType = Context.getCanonicalType(BaseType);
John McCall432887f2009-09-30 01:30:54 +00003929 if (!CTypes.insert(CBaseType)) {
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00003930 Diag(OpLoc, diag::err_operator_arrow_circular);
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00003931 for (unsigned i = 0; i < Locations.size(); i++)
3932 Diag(Locations[i], diag::note_declared_at);
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00003933 return ExprError();
3934 }
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003935 }
Mike Stump1eb44332009-09-09 15:08:12 +00003936
Douglas Gregor31658df2009-11-20 19:58:21 +00003937 if (BaseType->isPointerType())
3938 BaseType = BaseType->getPointeeType();
3939 }
Mike Stump1eb44332009-09-09 15:08:12 +00003940
3941 // We could end up with various non-record types here, such as extended
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003942 // vector types or Objective-C interfaces. Just return early and let
3943 // ActOnMemberReferenceExpr do the work.
Douglas Gregorc68afe22009-09-03 21:38:09 +00003944 if (!BaseType->isRecordType()) {
3945 // C++ [basic.lookup.classref]p2:
3946 // [...] If the type of the object expression is of pointer to scalar
3947 // type, the unqualified-id is looked up in the context of the complete
3948 // postfix-expression.
Douglas Gregord4dca082010-02-24 18:44:31 +00003949 //
3950 // This also indicates that we should be parsing a
3951 // pseudo-destructor-name.
John McCallb3d87482010-08-24 05:47:05 +00003952 ObjectType = ParsedType();
Douglas Gregord4dca082010-02-24 18:44:31 +00003953 MayBePseudoDestructor = true;
John McCall9ae2f072010-08-23 23:25:46 +00003954 return Owned(Base);
Douglas Gregorc68afe22009-09-03 21:38:09 +00003955 }
Mike Stump1eb44332009-09-09 15:08:12 +00003956
Douglas Gregor03c57052009-11-17 05:17:33 +00003957 // The object type must be complete (or dependent).
3958 if (!BaseType->isDependentType() &&
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003959 RequireCompleteType(OpLoc, BaseType,
Douglas Gregor03c57052009-11-17 05:17:33 +00003960 PDiag(diag::err_incomplete_member_access)))
3961 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003962
Douglas Gregorc68afe22009-09-03 21:38:09 +00003963 // C++ [basic.lookup.classref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00003964 // If the id-expression in a class member access (5.2.5) is an
Douglas Gregor03c57052009-11-17 05:17:33 +00003965 // unqualified-id, and the type of the object expression is of a class
Douglas Gregorc68afe22009-09-03 21:38:09 +00003966 // type C (or of pointer to a class type C), the unqualified-id is looked
3967 // up in the scope of class C. [...]
John McCallb3d87482010-08-24 05:47:05 +00003968 ObjectType = ParsedType::make(BaseType);
Mike Stump1eb44332009-09-09 15:08:12 +00003969 return move(Base);
Douglas Gregor2dd078a2009-09-02 22:59:36 +00003970}
3971
John McCall60d7b3a2010-08-24 06:29:42 +00003972ExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc,
John McCall9ae2f072010-08-23 23:25:46 +00003973 Expr *MemExpr) {
Douglas Gregor77549082010-02-24 21:29:12 +00003974 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc);
John McCall9ae2f072010-08-23 23:25:46 +00003975 Diag(MemExpr->getLocStart(), diag::err_dtor_expr_without_call)
3976 << isa<CXXPseudoDestructorExpr>(MemExpr)
Douglas Gregor849b2432010-03-31 17:46:05 +00003977 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003978
Douglas Gregor77549082010-02-24 21:29:12 +00003979 return ActOnCallExpr(/*Scope*/ 0,
John McCall9ae2f072010-08-23 23:25:46 +00003980 MemExpr,
Douglas Gregor77549082010-02-24 21:29:12 +00003981 /*LPLoc*/ ExpectedLParenLoc,
John McCallf312b1e2010-08-26 23:41:50 +00003982 MultiExprArg(),
Douglas Gregor77549082010-02-24 21:29:12 +00003983 /*RPLoc*/ ExpectedLParenLoc);
3984}
Douglas Gregord4dca082010-02-24 18:44:31 +00003985
John McCall60d7b3a2010-08-24 06:29:42 +00003986ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base,
John McCall2d9f5fa2011-02-25 05:21:17 +00003987 SourceLocation OpLoc,
3988 tok::TokenKind OpKind,
3989 const CXXScopeSpec &SS,
3990 TypeSourceInfo *ScopeTypeInfo,
3991 SourceLocation CCLoc,
3992 SourceLocation TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00003993 PseudoDestructorTypeStorage Destructed,
John McCall2d9f5fa2011-02-25 05:21:17 +00003994 bool HasTrailingLParen) {
Douglas Gregora2e7dd22010-02-25 01:56:36 +00003995 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003996
Douglas Gregorb57fb492010-02-24 22:38:50 +00003997 // C++ [expr.pseudo]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003998 // The left-hand side of the dot operator shall be of scalar type. The
Douglas Gregorb57fb492010-02-24 22:38:50 +00003999 // left-hand side of the arrow operator shall be of pointer to scalar type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004000 // This scalar type is the object type.
John McCall9ae2f072010-08-23 23:25:46 +00004001 QualType ObjectType = Base->getType();
Douglas Gregorb57fb492010-02-24 22:38:50 +00004002 if (OpKind == tok::arrow) {
4003 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
4004 ObjectType = Ptr->getPointeeType();
John McCall9ae2f072010-08-23 23:25:46 +00004005 } else if (!Base->isTypeDependent()) {
Douglas Gregorb57fb492010-02-24 22:38:50 +00004006 // The user wrote "p->" when she probably meant "p."; fix it.
4007 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
4008 << ObjectType << true
Douglas Gregor849b2432010-03-31 17:46:05 +00004009 << FixItHint::CreateReplacement(OpLoc, ".");
Douglas Gregorb57fb492010-02-24 22:38:50 +00004010 if (isSFINAEContext())
4011 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004012
Douglas Gregorb57fb492010-02-24 22:38:50 +00004013 OpKind = tok::period;
4014 }
4015 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004016
Douglas Gregorb57fb492010-02-24 22:38:50 +00004017 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) {
4018 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
John McCall9ae2f072010-08-23 23:25:46 +00004019 << ObjectType << Base->getSourceRange();
Douglas Gregorb57fb492010-02-24 22:38:50 +00004020 return ExprError();
4021 }
4022
4023 // C++ [expr.pseudo]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004024 // [...] The cv-unqualified versions of the object type and of the type
Douglas Gregorb57fb492010-02-24 22:38:50 +00004025 // designated by the pseudo-destructor-name shall be the same type.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004026 if (DestructedTypeInfo) {
4027 QualType DestructedType = DestructedTypeInfo->getType();
4028 SourceLocation DestructedTypeStart
Abramo Bagnarabd054db2010-05-20 10:00:11 +00004029 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004030 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() &&
4031 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
4032 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
John McCall9ae2f072010-08-23 23:25:46 +00004033 << ObjectType << DestructedType << Base->getSourceRange()
Abramo Bagnarabd054db2010-05-20 10:00:11 +00004034 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004035
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004036 // Recover by setting the destructed type to the object type.
4037 DestructedType = ObjectType;
4038 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
4039 DestructedTypeStart);
4040 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
4041 }
Douglas Gregorb57fb492010-02-24 22:38:50 +00004042 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004043
Douglas Gregorb57fb492010-02-24 22:38:50 +00004044 // C++ [expr.pseudo]p2:
4045 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
4046 // form
4047 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004048 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
Douglas Gregorb57fb492010-02-24 22:38:50 +00004049 //
4050 // shall designate the same scalar type.
4051 if (ScopeTypeInfo) {
4052 QualType ScopeType = ScopeTypeInfo->getType();
4053 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
John McCall81e317a2010-06-11 17:36:40 +00004054 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004055
Abramo Bagnarabd054db2010-05-20 10:00:11 +00004056 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
Douglas Gregorb57fb492010-02-24 22:38:50 +00004057 diag::err_pseudo_dtor_type_mismatch)
John McCall9ae2f072010-08-23 23:25:46 +00004058 << ObjectType << ScopeType << Base->getSourceRange()
Abramo Bagnarabd054db2010-05-20 10:00:11 +00004059 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004060
Douglas Gregorb57fb492010-02-24 22:38:50 +00004061 ScopeType = QualType();
4062 ScopeTypeInfo = 0;
4063 }
4064 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004065
John McCall9ae2f072010-08-23 23:25:46 +00004066 Expr *Result
4067 = new (Context) CXXPseudoDestructorExpr(Context, Base,
4068 OpKind == tok::arrow, OpLoc,
Douglas Gregorf3db29f2011-02-25 18:19:59 +00004069 SS.getWithLocInContext(Context),
John McCall9ae2f072010-08-23 23:25:46 +00004070 ScopeTypeInfo,
4071 CCLoc,
4072 TildeLoc,
4073 Destructed);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004074
Douglas Gregorb57fb492010-02-24 22:38:50 +00004075 if (HasTrailingLParen)
John McCall9ae2f072010-08-23 23:25:46 +00004076 return Owned(Result);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004077
John McCall9ae2f072010-08-23 23:25:46 +00004078 return DiagnoseDtorReference(Destructed.getLocation(), Result);
Douglas Gregor77549082010-02-24 21:29:12 +00004079}
4080
John McCall60d7b3a2010-08-24 06:29:42 +00004081ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
John McCall2d9f5fa2011-02-25 05:21:17 +00004082 SourceLocation OpLoc,
4083 tok::TokenKind OpKind,
4084 CXXScopeSpec &SS,
4085 UnqualifiedId &FirstTypeName,
4086 SourceLocation CCLoc,
4087 SourceLocation TildeLoc,
4088 UnqualifiedId &SecondTypeName,
4089 bool HasTrailingLParen) {
Douglas Gregor77549082010-02-24 21:29:12 +00004090 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
4091 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
4092 "Invalid first type name in pseudo-destructor");
4093 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
4094 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
4095 "Invalid second type name in pseudo-destructor");
4096
Douglas Gregor77549082010-02-24 21:29:12 +00004097 // C++ [expr.pseudo]p2:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004098 // The left-hand side of the dot operator shall be of scalar type. The
Douglas Gregor77549082010-02-24 21:29:12 +00004099 // left-hand side of the arrow operator shall be of pointer to scalar type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004100 // This scalar type is the object type.
John McCall9ae2f072010-08-23 23:25:46 +00004101 QualType ObjectType = Base->getType();
Douglas Gregor77549082010-02-24 21:29:12 +00004102 if (OpKind == tok::arrow) {
4103 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
4104 ObjectType = Ptr->getPointeeType();
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004105 } else if (!ObjectType->isDependentType()) {
Douglas Gregor77549082010-02-24 21:29:12 +00004106 // The user wrote "p->" when she probably meant "p."; fix it.
4107 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004108 << ObjectType << true
Douglas Gregor849b2432010-03-31 17:46:05 +00004109 << FixItHint::CreateReplacement(OpLoc, ".");
Douglas Gregor77549082010-02-24 21:29:12 +00004110 if (isSFINAEContext())
4111 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004112
Douglas Gregor77549082010-02-24 21:29:12 +00004113 OpKind = tok::period;
4114 }
4115 }
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004116
4117 // Compute the object type that we should use for name lookup purposes. Only
4118 // record types and dependent types matter.
John McCallb3d87482010-08-24 05:47:05 +00004119 ParsedType ObjectTypePtrForLookup;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004120 if (!SS.isSet()) {
John McCall2d9f5fa2011-02-25 05:21:17 +00004121 if (ObjectType->isRecordType())
4122 ObjectTypePtrForLookup = ParsedType::make(ObjectType);
John McCallb3d87482010-08-24 05:47:05 +00004123 else if (ObjectType->isDependentType())
4124 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004125 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004126
4127 // Convert the name of the type being destructed (following the ~) into a
Douglas Gregorb57fb492010-02-24 22:38:50 +00004128 // type (with source-location information).
Douglas Gregor77549082010-02-24 21:29:12 +00004129 QualType DestructedType;
4130 TypeSourceInfo *DestructedTypeInfo = 0;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004131 PseudoDestructorTypeStorage Destructed;
Douglas Gregor77549082010-02-24 21:29:12 +00004132 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004133 ParsedType T = getTypeName(*SecondTypeName.Identifier,
John McCallb3d87482010-08-24 05:47:05 +00004134 SecondTypeName.StartLocation,
Fariborz Jahanian1e52dfc2011-02-08 18:05:59 +00004135 S, &SS, true, false, ObjectTypePtrForLookup);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004136 if (!T &&
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004137 ((SS.isSet() && !computeDeclContext(SS, false)) ||
4138 (!SS.isSet() && ObjectType->isDependentType()))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004139 // The name of the type being destroyed is a dependent name, and we
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004140 // couldn't find anything useful in scope. Just store the identifier and
4141 // it's location, and we'll perform (qualified) name lookup again at
4142 // template instantiation time.
4143 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
4144 SecondTypeName.StartLocation);
4145 } else if (!T) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004146 Diag(SecondTypeName.StartLocation,
Douglas Gregor77549082010-02-24 21:29:12 +00004147 diag::err_pseudo_dtor_destructor_non_type)
4148 << SecondTypeName.Identifier << ObjectType;
4149 if (isSFINAEContext())
4150 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004151
Douglas Gregor77549082010-02-24 21:29:12 +00004152 // Recover by assuming we had the right type all along.
4153 DestructedType = ObjectType;
Douglas Gregorb57fb492010-02-24 22:38:50 +00004154 } else
Douglas Gregor77549082010-02-24 21:29:12 +00004155 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00004156 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00004157 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00004158 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
Douglas Gregorb57fb492010-02-24 22:38:50 +00004159 ASTTemplateArgsPtr TemplateArgsPtr(*this,
4160 TemplateId->getTemplateArgs(),
4161 TemplateId->NumArgs);
Douglas Gregor059101f2011-03-02 00:47:37 +00004162 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
4163 TemplateId->Template,
Douglas Gregorb57fb492010-02-24 22:38:50 +00004164 TemplateId->TemplateNameLoc,
4165 TemplateId->LAngleLoc,
4166 TemplateArgsPtr,
4167 TemplateId->RAngleLoc);
4168 if (T.isInvalid() || !T.get()) {
4169 // Recover by assuming we had the right type all along.
4170 DestructedType = ObjectType;
4171 } else
4172 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00004173 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004174
4175 // If we've performed some kind of recovery, (re-)build the type source
Douglas Gregorb57fb492010-02-24 22:38:50 +00004176 // information.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004177 if (!DestructedType.isNull()) {
4178 if (!DestructedTypeInfo)
4179 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
Douglas Gregorb57fb492010-02-24 22:38:50 +00004180 SecondTypeName.StartLocation);
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004181 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
4182 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004183
Douglas Gregorb57fb492010-02-24 22:38:50 +00004184 // Convert the name of the scope type (the type prior to '::') into a type.
4185 TypeSourceInfo *ScopeTypeInfo = 0;
Douglas Gregor77549082010-02-24 21:29:12 +00004186 QualType ScopeType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004187 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
Douglas Gregor77549082010-02-24 21:29:12 +00004188 FirstTypeName.Identifier) {
4189 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004190 ParsedType T = getTypeName(*FirstTypeName.Identifier,
John McCallb3d87482010-08-24 05:47:05 +00004191 FirstTypeName.StartLocation,
Douglas Gregorf3db29f2011-02-25 18:19:59 +00004192 S, &SS, true, false, ObjectTypePtrForLookup);
Douglas Gregor77549082010-02-24 21:29:12 +00004193 if (!T) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004194 Diag(FirstTypeName.StartLocation,
Douglas Gregor77549082010-02-24 21:29:12 +00004195 diag::err_pseudo_dtor_destructor_non_type)
4196 << FirstTypeName.Identifier << ObjectType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004197
Douglas Gregorb57fb492010-02-24 22:38:50 +00004198 if (isSFINAEContext())
4199 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004200
Douglas Gregorb57fb492010-02-24 22:38:50 +00004201 // Just drop this type. It's unnecessary anyway.
4202 ScopeType = QualType();
4203 } else
4204 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00004205 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00004206 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00004207 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
Douglas Gregorb57fb492010-02-24 22:38:50 +00004208 ASTTemplateArgsPtr TemplateArgsPtr(*this,
4209 TemplateId->getTemplateArgs(),
4210 TemplateId->NumArgs);
Douglas Gregor059101f2011-03-02 00:47:37 +00004211 TypeResult T = ActOnTemplateIdType(TemplateId->SS,
4212 TemplateId->Template,
Douglas Gregorb57fb492010-02-24 22:38:50 +00004213 TemplateId->TemplateNameLoc,
4214 TemplateId->LAngleLoc,
4215 TemplateArgsPtr,
4216 TemplateId->RAngleLoc);
4217 if (T.isInvalid() || !T.get()) {
4218 // Recover by dropping this type.
4219 ScopeType = QualType();
4220 } else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004221 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00004222 }
4223 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004224
Douglas Gregorb4a418f2010-02-24 23:02:30 +00004225 if (!ScopeType.isNull() && !ScopeTypeInfo)
4226 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
4227 FirstTypeName.StartLocation);
4228
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004229
John McCall9ae2f072010-08-23 23:25:46 +00004230 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
Douglas Gregorfce46ee2010-02-24 23:50:37 +00004231 ScopeTypeInfo, CCLoc, TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00004232 Destructed, HasTrailingLParen);
Douglas Gregord4dca082010-02-24 18:44:31 +00004233}
4234
John Wiegley429bb272011-04-08 18:41:53 +00004235ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
Douglas Gregorf2ae5262011-01-20 00:18:04 +00004236 CXXMethodDecl *Method) {
John Wiegley429bb272011-04-08 18:41:53 +00004237 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/0,
4238 FoundDecl, Method);
4239 if (Exp.isInvalid())
Douglas Gregorf2ae5262011-01-20 00:18:04 +00004240 return true;
Eli Friedman772fffa2009-12-09 04:53:56 +00004241
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004242 MemberExpr *ME =
John Wiegley429bb272011-04-08 18:41:53 +00004243 new (Context) MemberExpr(Exp.take(), /*IsArrow=*/false, Method,
John McCallf89e55a2010-11-18 06:31:45 +00004244 SourceLocation(), Method->getType(),
4245 VK_RValue, OK_Ordinary);
4246 QualType ResultType = Method->getResultType();
4247 ExprValueKind VK = Expr::getValueKindForType(ResultType);
4248 ResultType = ResultType.getNonLValueExprType(Context);
4249
John Wiegley429bb272011-04-08 18:41:53 +00004250 MarkDeclarationReferenced(Exp.get()->getLocStart(), Method);
Douglas Gregor7edfb692009-11-23 12:27:39 +00004251 CXXMemberCallExpr *CE =
John McCallf89e55a2010-11-18 06:31:45 +00004252 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, VK,
John Wiegley429bb272011-04-08 18:41:53 +00004253 Exp.get()->getLocEnd());
Fariborz Jahanianb7400232009-09-28 23:23:40 +00004254 return CE;
4255}
4256
Sebastian Redl2e156222010-09-10 20:55:43 +00004257ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
4258 SourceLocation RParen) {
Sebastian Redl2e156222010-09-10 20:55:43 +00004259 return Owned(new (Context) CXXNoexceptExpr(Context.BoolTy, Operand,
4260 Operand->CanThrow(Context),
4261 KeyLoc, RParen));
4262}
4263
4264ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation,
4265 Expr *Operand, SourceLocation RParen) {
4266 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
Sebastian Redl02bc21a2010-09-10 20:55:37 +00004267}
4268
John McCallf6a16482010-12-04 03:47:34 +00004269/// Perform the conversions required for an expression used in a
4270/// context that ignores the result.
John Wiegley429bb272011-04-08 18:41:53 +00004271ExprResult Sema::IgnoredValueConversions(Expr *E) {
John McCalla878cda2010-12-02 02:07:15 +00004272 // C99 6.3.2.1:
4273 // [Except in specific positions,] an lvalue that does not have
4274 // array type is converted to the value stored in the
4275 // designated object (and is no longer an lvalue).
John Wiegley429bb272011-04-08 18:41:53 +00004276 if (E->isRValue()) return Owned(E);
John McCalla878cda2010-12-02 02:07:15 +00004277
John McCallf6a16482010-12-04 03:47:34 +00004278 // We always want to do this on ObjC property references.
4279 if (E->getObjectKind() == OK_ObjCProperty) {
John Wiegley429bb272011-04-08 18:41:53 +00004280 ExprResult Res = ConvertPropertyForRValue(E);
4281 if (Res.isInvalid()) return Owned(E);
4282 E = Res.take();
4283 if (E->isRValue()) return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00004284 }
4285
4286 // Otherwise, this rule does not apply in C++, at least not for the moment.
John Wiegley429bb272011-04-08 18:41:53 +00004287 if (getLangOptions().CPlusPlus) return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00004288
4289 // GCC seems to also exclude expressions of incomplete enum type.
4290 if (const EnumType *T = E->getType()->getAs<EnumType>()) {
4291 if (!T->getDecl()->isComplete()) {
4292 // FIXME: stupid workaround for a codegen bug!
John Wiegley429bb272011-04-08 18:41:53 +00004293 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).take();
4294 return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00004295 }
4296 }
4297
John Wiegley429bb272011-04-08 18:41:53 +00004298 ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
4299 if (Res.isInvalid())
4300 return Owned(E);
4301 E = Res.take();
4302
John McCall85515d62010-12-04 12:29:11 +00004303 if (!E->getType()->isVoidType())
4304 RequireCompleteType(E->getExprLoc(), E->getType(),
4305 diag::err_incomplete_type);
John Wiegley429bb272011-04-08 18:41:53 +00004306 return Owned(E);
John McCallf6a16482010-12-04 03:47:34 +00004307}
4308
John Wiegley429bb272011-04-08 18:41:53 +00004309ExprResult Sema::ActOnFinishFullExpr(Expr *FE) {
4310 ExprResult FullExpr = Owned(FE);
4311
4312 if (!FullExpr.get())
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00004313 return ExprError();
John McCallf6a16482010-12-04 03:47:34 +00004314
John Wiegley429bb272011-04-08 18:41:53 +00004315 if (DiagnoseUnexpandedParameterPack(FullExpr.get()))
Douglas Gregord0937222010-12-13 22:49:22 +00004316 return ExprError();
4317
John McCallfb8721c2011-04-10 19:13:55 +00004318 FullExpr = CheckPlaceholderExpr(FullExpr.take());
4319 if (FullExpr.isInvalid())
4320 return ExprError();
Douglas Gregor353ee242011-03-07 02:05:23 +00004321
John Wiegley429bb272011-04-08 18:41:53 +00004322 FullExpr = IgnoredValueConversions(FullExpr.take());
4323 if (FullExpr.isInvalid())
4324 return ExprError();
4325
4326 CheckImplicitConversions(FullExpr.get());
John McCall4765fa02010-12-06 08:20:24 +00004327 return MaybeCreateExprWithCleanups(FullExpr);
Anders Carlsson165a0a02009-05-17 18:41:29 +00004328}
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004329
4330StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
4331 if (!FullStmt) return StmtError();
4332
John McCall4765fa02010-12-06 08:20:24 +00004333 return MaybeCreateStmtWithCleanups(FullStmt);
Argyrios Kyrtzidisbf8cafa2010-11-02 02:33:08 +00004334}
Francois Pichet1e862692011-05-06 20:48:22 +00004335
4336bool Sema::CheckMicrosoftIfExistsSymbol(CXXScopeSpec &SS,
4337 UnqualifiedId &Name) {
4338 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
4339 DeclarationName TargetName = TargetNameInfo.getName();
4340 if (!TargetName)
4341 return false;
4342
4343 // Do the redeclaration lookup in the current scope.
4344 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
4345 Sema::NotForRedeclaration);
4346 R.suppressDiagnostics();
4347 LookupParsedName(R, getCurScope(), &SS);
4348 return !R.empty();
4349}