blob: 52dc6d8fa4f316e37443c3ed8a1e80ca291cc32e [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
14#include "Sema.h"
Douglas Gregor20093b42009-12-09 23:02:17 +000015#include "SemaInit.h"
John McCall7d384dd2009-11-18 07:57:50 +000016#include "Lookup.h"
Steve Naroff210679c2007-08-25 14:02:58 +000017#include "clang/AST/ASTContext.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000018#include "clang/AST/CXXInheritance.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000019#include "clang/AST/ExprCXX.h"
Douglas Gregorb57fb492010-02-24 22:38:50 +000020#include "clang/AST/TypeLoc.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000021#include "clang/Basic/PartialDiagnostic.h"
Sebastian Redlb5a57a62008-12-03 20:26:15 +000022#include "clang/Basic/TargetInfo.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000023#include "clang/Lex/Preprocessor.h"
24#include "clang/Parse/DeclSpec.h"
Douglas Gregord4dca082010-02-24 18:44:31 +000025#include "clang/Parse/Template.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000026#include "llvm/ADT/STLExtras.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000027using namespace clang;
28
Douglas Gregor124b8782010-02-16 19:09:40 +000029Action::TypeTy *Sema::getDestructorName(SourceLocation TildeLoc,
30 IdentifierInfo &II,
31 SourceLocation NameLoc,
32 Scope *S, const CXXScopeSpec &SS,
33 TypeTy *ObjectTypePtr,
34 bool EnteringContext) {
35 // Determine where to perform name lookup.
36
37 // FIXME: This area of the standard is very messy, and the current
38 // wording is rather unclear about which scopes we search for the
39 // destructor name; see core issues 399 and 555. Issue 399 in
40 // particular shows where the current description of destructor name
41 // lookup is completely out of line with existing practice, e.g.,
42 // this appears to be ill-formed:
43 //
44 // namespace N {
45 // template <typename T> struct S {
46 // ~S();
47 // };
48 // }
49 //
50 // void f(N::S<int>* s) {
51 // s->N::S<int>::~S();
52 // }
53 //
Douglas Gregor93649fd2010-02-23 00:15:22 +000054 // See also PR6358 and PR6359.
Douglas Gregor124b8782010-02-16 19:09:40 +000055 QualType SearchType;
56 DeclContext *LookupCtx = 0;
57 bool isDependent = false;
58 bool LookInScope = false;
59
60 // If we have an object type, it's because we are in a
61 // pseudo-destructor-expression or a member access expression, and
62 // we know what type we're looking for.
63 if (ObjectTypePtr)
64 SearchType = GetTypeFromParser(ObjectTypePtr);
65
66 if (SS.isSet()) {
Douglas Gregor93649fd2010-02-23 00:15:22 +000067 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
68
69 bool AlreadySearched = false;
70 bool LookAtPrefix = true;
71 if (!getLangOptions().CPlusPlus0x) {
72 // C++ [basic.lookup.qual]p6:
73 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
74 // the type-names are looked up as types in the scope designated by the
75 // nested-name-specifier. In a qualified-id of the form:
76 //
77 // ::[opt] nested-name-specifier ̃ class-name
78 //
79 // where the nested-name-specifier designates a namespace scope, and in
80 // a qualified-id of the form:
81 //
82 // ::opt nested-name-specifier class-name :: ̃ class-name
83 //
84 // the class-names are looked up as types in the scope designated by
85 // the nested-name-specifier.
86 //
87 // Here, we check the first case (completely) and determine whether the
88 // code below is permitted to look at the prefix of the
89 // nested-name-specifier (as we do in C++0x).
90 DeclContext *DC = computeDeclContext(SS, EnteringContext);
91 if (DC && DC->isFileContext()) {
92 AlreadySearched = true;
93 LookupCtx = DC;
94 isDependent = false;
95 } else if (DC && isa<CXXRecordDecl>(DC))
96 LookAtPrefix = false;
97 }
98
99 // C++0x [basic.lookup.qual]p6:
Douglas Gregor124b8782010-02-16 19:09:40 +0000100 // If a pseudo-destructor-name (5.2.4) contains a
101 // nested-name-specifier, the type-names are looked up as types
102 // in the scope designated by the nested-name-specifier. Similarly, in
Chandler Carruth5e895a82010-02-21 10:19:54 +0000103 // a qualified-id of the form:
Douglas Gregor124b8782010-02-16 19:09:40 +0000104 //
105 // :: [opt] nested-name-specifier[opt] class-name :: ~class-name
106 //
107 // the second class-name is looked up in the same scope as the first.
108 //
Douglas Gregor93649fd2010-02-23 00:15:22 +0000109 // To implement this, we look at the prefix of the
110 // nested-name-specifier we were given, and determine the lookup
111 // context from that.
112 //
113 // We also fold in the second case from the C++03 rules quoted further
114 // above.
115 NestedNameSpecifier *Prefix = 0;
116 if (AlreadySearched) {
117 // Nothing left to do.
118 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
119 CXXScopeSpec PrefixSS;
120 PrefixSS.setScopeRep(Prefix);
121 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
122 isDependent = isDependentScopeSpecifier(PrefixSS);
123 } else if (getLangOptions().CPlusPlus0x &&
124 (LookupCtx = computeDeclContext(SS, EnteringContext))) {
125 if (!LookupCtx->isTranslationUnit())
126 LookupCtx = LookupCtx->getParent();
127 isDependent = LookupCtx && LookupCtx->isDependentContext();
128 } else if (ObjectTypePtr) {
Douglas Gregor124b8782010-02-16 19:09:40 +0000129 LookupCtx = computeDeclContext(SearchType);
130 isDependent = SearchType->isDependentType();
131 } else {
132 LookupCtx = computeDeclContext(SS, EnteringContext);
Douglas Gregor93649fd2010-02-23 00:15:22 +0000133 isDependent = LookupCtx && LookupCtx->isDependentContext();
Douglas Gregor124b8782010-02-16 19:09:40 +0000134 }
Douglas Gregor93649fd2010-02-23 00:15:22 +0000135
Douglas Gregoredc90502010-02-25 04:46:04 +0000136 LookInScope = false;
Douglas Gregor124b8782010-02-16 19:09:40 +0000137 } else if (ObjectTypePtr) {
138 // C++ [basic.lookup.classref]p3:
139 // If the unqualified-id is ~type-name, the type-name is looked up
140 // in the context of the entire postfix-expression. If the type T
141 // of the object expression is of a class type C, the type-name is
142 // also looked up in the scope of class C. At least one of the
143 // lookups shall find a name that refers to (possibly
144 // cv-qualified) T.
145 LookupCtx = computeDeclContext(SearchType);
146 isDependent = SearchType->isDependentType();
147 assert((isDependent || !SearchType->isIncompleteType()) &&
148 "Caller should have completed object type");
149
150 LookInScope = true;
151 } else {
152 // Perform lookup into the current scope (only).
153 LookInScope = true;
154 }
155
156 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
157 for (unsigned Step = 0; Step != 2; ++Step) {
158 // Look for the name first in the computed lookup context (if we
159 // have one) and, if that fails to find a match, in the sope (if
160 // we're allowed to look there).
161 Found.clear();
162 if (Step == 0 && LookupCtx)
163 LookupQualifiedName(Found, LookupCtx);
Douglas Gregora2e7dd22010-02-25 01:56:36 +0000164 else if (Step == 1 && LookInScope && S)
Douglas Gregor124b8782010-02-16 19:09:40 +0000165 LookupName(Found, S);
166 else
167 continue;
168
169 // FIXME: Should we be suppressing ambiguities here?
170 if (Found.isAmbiguous())
171 return 0;
172
173 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
174 QualType T = Context.getTypeDeclType(Type);
Douglas Gregor124b8782010-02-16 19:09:40 +0000175
176 if (SearchType.isNull() || SearchType->isDependentType() ||
177 Context.hasSameUnqualifiedType(T, SearchType)) {
178 // We found our type!
179
180 return T.getAsOpaquePtr();
181 }
182 }
183
184 // If the name that we found is a class template name, and it is
185 // the same name as the template name in the last part of the
186 // nested-name-specifier (if present) or the object type, then
187 // this is the destructor for that class.
188 // FIXME: This is a workaround until we get real drafting for core
189 // issue 399, for which there isn't even an obvious direction.
190 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
191 QualType MemberOfType;
192 if (SS.isSet()) {
193 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
194 // Figure out the type of the context, if it has one.
John McCall3cb0ebd2010-03-10 03:28:59 +0000195 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
196 MemberOfType = Context.getTypeDeclType(Record);
Douglas Gregor124b8782010-02-16 19:09:40 +0000197 }
198 }
199 if (MemberOfType.isNull())
200 MemberOfType = SearchType;
201
202 if (MemberOfType.isNull())
203 continue;
204
205 // We're referring into a class template specialization. If the
206 // class template we found is the same as the template being
207 // specialized, we found what we are looking for.
208 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
209 if (ClassTemplateSpecializationDecl *Spec
210 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
211 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
212 Template->getCanonicalDecl())
213 return MemberOfType.getAsOpaquePtr();
214 }
215
216 continue;
217 }
218
219 // We're referring to an unresolved class template
220 // specialization. Determine whether we class template we found
221 // is the same as the template being specialized or, if we don't
222 // know which template is being specialized, that it at least
223 // has the same name.
224 if (const TemplateSpecializationType *SpecType
225 = MemberOfType->getAs<TemplateSpecializationType>()) {
226 TemplateName SpecName = SpecType->getTemplateName();
227
228 // The class template we found is the same template being
229 // specialized.
230 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
231 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
232 return MemberOfType.getAsOpaquePtr();
233
234 continue;
235 }
236
237 // The class template we found has the same name as the
238 // (dependent) template name being specialized.
239 if (DependentTemplateName *DepTemplate
240 = SpecName.getAsDependentTemplateName()) {
241 if (DepTemplate->isIdentifier() &&
242 DepTemplate->getIdentifier() == Template->getIdentifier())
243 return MemberOfType.getAsOpaquePtr();
244
245 continue;
246 }
247 }
248 }
249 }
250
251 if (isDependent) {
252 // We didn't find our type, but that's okay: it's dependent
253 // anyway.
254 NestedNameSpecifier *NNS = 0;
255 SourceRange Range;
256 if (SS.isSet()) {
257 NNS = (NestedNameSpecifier *)SS.getScopeRep();
258 Range = SourceRange(SS.getRange().getBegin(), NameLoc);
259 } else {
260 NNS = NestedNameSpecifier::Create(Context, &II);
261 Range = SourceRange(NameLoc);
262 }
263
264 return CheckTypenameType(NNS, II, Range).getAsOpaquePtr();
265 }
266
267 if (ObjectTypePtr)
268 Diag(NameLoc, diag::err_ident_in_pseudo_dtor_not_a_type)
269 << &II;
270 else
271 Diag(NameLoc, diag::err_destructor_class_name);
272
273 return 0;
274}
275
Sebastian Redlc42e1182008-11-11 11:37:55 +0000276/// ActOnCXXTypeidOfType - Parse typeid( type-id ).
Sebastian Redlf53597f2009-03-15 17:47:39 +0000277Action::OwningExprResult
Sebastian Redlc42e1182008-11-11 11:37:55 +0000278Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
279 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +0000280 if (!StdNamespace)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000281 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000282
Douglas Gregorf57f2072009-12-23 20:51:04 +0000283 if (isType) {
284 // C++ [expr.typeid]p4:
285 // The top-level cv-qualifiers of the lvalue expression or the type-id
286 // that is the operand of typeid are always ignored.
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000287 // FIXME: Preserve type source info.
Douglas Gregorf57f2072009-12-23 20:51:04 +0000288 // FIXME: Preserve the type before we stripped the cv-qualifiers?
Douglas Gregor765ccba2009-12-23 21:06:06 +0000289 QualType T = GetTypeFromParser(TyOrExpr);
290 if (T.isNull())
291 return ExprError();
292
293 // C++ [expr.typeid]p4:
294 // If the type of the type-id is a class type or a reference to a class
295 // type, the class shall be completely-defined.
296 QualType CheckT = T;
297 if (const ReferenceType *RefType = CheckT->getAs<ReferenceType>())
298 CheckT = RefType->getPointeeType();
299
300 if (CheckT->getAs<RecordType>() &&
301 RequireCompleteType(OpLoc, CheckT, diag::err_incomplete_typeid))
302 return ExprError();
303
304 TyOrExpr = T.getUnqualifiedType().getAsOpaquePtr();
Douglas Gregorf57f2072009-12-23 20:51:04 +0000305 }
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000306
Chris Lattner572af492008-11-20 05:51:55 +0000307 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
John McCalla24dc2e2009-11-17 02:14:36 +0000308 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
309 LookupQualifiedName(R, StdNamespace);
John McCall1bcee0a2009-12-02 08:25:40 +0000310 RecordDecl *TypeInfoRecordDecl = R.getAsSingle<RecordDecl>();
Chris Lattner572af492008-11-20 05:51:55 +0000311 if (!TypeInfoRecordDecl)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000312 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
Sebastian Redlc42e1182008-11-11 11:37:55 +0000313
314 QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl);
315
Douglas Gregorac7610d2009-06-22 20:57:11 +0000316 if (!isType) {
Douglas Gregorac7610d2009-06-22 20:57:11 +0000317 bool isUnevaluatedOperand = true;
318 Expr *E = static_cast<Expr *>(TyOrExpr);
Douglas Gregorf57f2072009-12-23 20:51:04 +0000319 if (E && !E->isTypeDependent()) {
Douglas Gregorac7610d2009-06-22 20:57:11 +0000320 QualType T = E->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000321 if (const RecordType *RecordT = T->getAs<RecordType>()) {
Douglas Gregorac7610d2009-06-22 20:57:11 +0000322 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
Douglas Gregorf57f2072009-12-23 20:51:04 +0000323 // C++ [expr.typeid]p3:
John McCall86ff3082010-02-04 22:26:26 +0000324 // [...] If the type of the expression is a class type, the class
325 // shall be completely-defined.
326 if (RequireCompleteType(OpLoc, T, diag::err_incomplete_typeid))
327 return ExprError();
328
329 // C++ [expr.typeid]p3:
Douglas Gregorf57f2072009-12-23 20:51:04 +0000330 // When typeid is applied to an expression other than an lvalue of a
331 // polymorphic class type [...] [the] expression is an unevaluated
332 // operand. [...]
333 if (RecordD->isPolymorphic() && E->isLvalue(Context) == Expr::LV_Valid)
Douglas Gregorac7610d2009-06-22 20:57:11 +0000334 isUnevaluatedOperand = false;
Douglas Gregorf57f2072009-12-23 20:51:04 +0000335 }
336
337 // C++ [expr.typeid]p4:
338 // [...] If the type of the type-id is a reference to a possibly
339 // cv-qualified type, the result of the typeid expression refers to a
340 // std::type_info object representing the cv-unqualified referenced
341 // type.
342 if (T.hasQualifiers()) {
343 ImpCastExprToType(E, T.getUnqualifiedType(), CastExpr::CK_NoOp,
344 E->isLvalue(Context));
345 TyOrExpr = E;
Douglas Gregorac7610d2009-06-22 20:57:11 +0000346 }
347 }
Mike Stump1eb44332009-09-09 15:08:12 +0000348
Douglas Gregor2afce722009-11-26 00:44:06 +0000349 // If this is an unevaluated operand, clear out the set of
350 // declaration references we have been computing and eliminate any
351 // temporaries introduced in its computation.
Douglas Gregorac7610d2009-06-22 20:57:11 +0000352 if (isUnevaluatedOperand)
Douglas Gregor2afce722009-11-26 00:44:06 +0000353 ExprEvalContexts.back().Context = Unevaluated;
Douglas Gregorac7610d2009-06-22 20:57:11 +0000354 }
Mike Stump1eb44332009-09-09 15:08:12 +0000355
Sebastian Redlf53597f2009-03-15 17:47:39 +0000356 return Owned(new (Context) CXXTypeidExpr(isType, TyOrExpr,
357 TypeInfoType.withConst(),
358 SourceRange(OpLoc, RParenLoc)));
Sebastian Redlc42e1182008-11-11 11:37:55 +0000359}
360
Steve Naroff1b273c42007-09-16 14:56:35 +0000361/// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +0000362Action::OwningExprResult
Steve Naroff1b273c42007-09-16 14:56:35 +0000363Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
Douglas Gregor2f639b92008-10-24 15:36:09 +0000364 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
Reid Spencer5f016e22007-07-11 17:01:13 +0000365 "Unknown C++ Boolean value!");
Sebastian Redlf53597f2009-03-15 17:47:39 +0000366 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
367 Context.BoolTy, OpLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +0000368}
Chris Lattner50dd2892008-02-26 00:51:44 +0000369
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000370/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
371Action::OwningExprResult
372Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
373 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
374}
375
Chris Lattner50dd2892008-02-26 00:51:44 +0000376/// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +0000377Action::OwningExprResult
378Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprArg E) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000379 Expr *Ex = E.takeAs<Expr>();
380 if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex))
381 return ExprError();
382 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc));
383}
384
385/// CheckCXXThrowOperand - Validate the operand of a throw.
386bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) {
387 // C++ [except.throw]p3:
Douglas Gregor154fe982009-12-23 22:04:40 +0000388 // A throw-expression initializes a temporary object, called the exception
389 // object, the type of which is determined by removing any top-level
390 // cv-qualifiers from the static type of the operand of throw and adjusting
391 // the type from "array of T" or "function returning T" to "pointer to T"
392 // or "pointer to function returning T", [...]
393 if (E->getType().hasQualifiers())
394 ImpCastExprToType(E, E->getType().getUnqualifiedType(), CastExpr::CK_NoOp,
395 E->isLvalue(Context) == Expr::LV_Valid);
396
Sebastian Redl972041f2009-04-27 20:27:31 +0000397 DefaultFunctionArrayConversion(E);
398
399 // If the type of the exception would be an incomplete type or a pointer
400 // to an incomplete type other than (cv) void the program is ill-formed.
401 QualType Ty = E->getType();
402 int isPointer = 0;
Ted Kremenek6217b802009-07-29 21:53:49 +0000403 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
Sebastian Redl972041f2009-04-27 20:27:31 +0000404 Ty = Ptr->getPointeeType();
405 isPointer = 1;
406 }
407 if (!isPointer || !Ty->isVoidType()) {
408 if (RequireCompleteType(ThrowLoc, Ty,
Anders Carlssond497ba72009-08-26 22:59:12 +0000409 PDiag(isPointer ? diag::err_throw_incomplete_ptr
410 : diag::err_throw_incomplete)
411 << E->getSourceRange()))
Sebastian Redl972041f2009-04-27 20:27:31 +0000412 return true;
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000413
414 // FIXME: This is just a hack to mark the copy constructor referenced.
415 // This should go away when the next FIXME is fixed.
416 const RecordType *RT = Ty->getAs<RecordType>();
417 if (!RT)
418 return false;
419
420 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
421 if (RD->hasTrivialCopyConstructor())
422 return false;
423 CXXConstructorDecl *CopyCtor = RD->getCopyConstructor(Context, 0);
424 MarkDeclarationReferenced(ThrowLoc, CopyCtor);
Sebastian Redl972041f2009-04-27 20:27:31 +0000425 }
426
427 // FIXME: Construct a temporary here.
428 return false;
Chris Lattner50dd2892008-02-26 00:51:44 +0000429}
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000430
Sebastian Redlf53597f2009-03-15 17:47:39 +0000431Action::OwningExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000432 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
433 /// is a non-lvalue expression whose value is the address of the object for
434 /// which the function is called.
435
Sebastian Redlf53597f2009-03-15 17:47:39 +0000436 if (!isa<FunctionDecl>(CurContext))
437 return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000438
439 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext))
440 if (MD->isInstance())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000441 return Owned(new (Context) CXXThisExpr(ThisLoc,
Douglas Gregor828a1972010-01-07 23:12:05 +0000442 MD->getThisType(Context),
443 /*isImplicit=*/false));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000444
Sebastian Redlf53597f2009-03-15 17:47:39 +0000445 return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000446}
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000447
448/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
449/// Can be interpreted either as function-style casting ("int(x)")
450/// or class type construction ("ClassType(x,y,z)")
451/// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +0000452Action::OwningExprResult
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000453Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep,
454 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000455 MultiExprArg exprs,
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000456 SourceLocation *CommaLocs,
457 SourceLocation RParenLoc) {
Douglas Gregorae4c77d2010-02-05 19:11:37 +0000458 if (!TypeRep)
459 return ExprError();
460
John McCall9d125032010-01-15 18:39:57 +0000461 TypeSourceInfo *TInfo;
462 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
463 if (!TInfo)
464 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
Sebastian Redlf53597f2009-03-15 17:47:39 +0000465 unsigned NumExprs = exprs.size();
466 Expr **Exprs = (Expr**)exprs.get();
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000467 SourceLocation TyBeginLoc = TypeRange.getBegin();
468 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc);
469
Sebastian Redlf53597f2009-03-15 17:47:39 +0000470 if (Ty->isDependentType() ||
Douglas Gregorba498172009-03-13 21:01:28 +0000471 CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) {
Sebastian Redlf53597f2009-03-15 17:47:39 +0000472 exprs.release();
Mike Stump1eb44332009-09-09 15:08:12 +0000473
474 return Owned(CXXUnresolvedConstructExpr::Create(Context,
475 TypeRange.getBegin(), Ty,
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000476 LParenLoc,
477 Exprs, NumExprs,
478 RParenLoc));
Douglas Gregorba498172009-03-13 21:01:28 +0000479 }
480
Anders Carlssonbb60a502009-08-27 03:53:50 +0000481 if (Ty->isArrayType())
482 return ExprError(Diag(TyBeginLoc,
483 diag::err_value_init_for_array_type) << FullRange);
484 if (!Ty->isVoidType() &&
485 RequireCompleteType(TyBeginLoc, Ty,
486 PDiag(diag::err_invalid_incomplete_type_use)
487 << FullRange))
488 return ExprError();
Fariborz Jahanianf071e9b2009-10-23 21:01:39 +0000489
Anders Carlssonbb60a502009-08-27 03:53:50 +0000490 if (RequireNonAbstractType(TyBeginLoc, Ty,
491 diag::err_allocation_of_abstract_type))
492 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +0000493
494
Douglas Gregor506ae412009-01-16 18:33:17 +0000495 // C++ [expr.type.conv]p1:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000496 // If the expression list is a single expression, the type conversion
497 // expression is equivalent (in definedness, and if defined in meaning) to the
498 // corresponding cast expression.
499 //
500 if (NumExprs == 1) {
Anders Carlssoncdb61972009-08-07 22:21:05 +0000501 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
Anders Carlsson0aebc812009-09-09 21:33:21 +0000502 CXXMethodDecl *Method = 0;
503 if (CheckCastTypes(TypeRange, Ty, Exprs[0], Kind, Method,
504 /*FunctionalStyle=*/true))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000505 return ExprError();
Anders Carlsson0aebc812009-09-09 21:33:21 +0000506
507 exprs.release();
508 if (Method) {
509 OwningExprResult CastArg
510 = BuildCXXCastArgument(TypeRange.getBegin(), Ty.getNonReferenceType(),
511 Kind, Method, Owned(Exprs[0]));
512 if (CastArg.isInvalid())
513 return ExprError();
514
515 Exprs[0] = CastArg.takeAs<Expr>();
Fariborz Jahanian4fc7ab32009-08-28 15:11:24 +0000516 }
Anders Carlsson0aebc812009-09-09 21:33:21 +0000517
518 return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(),
John McCall9d125032010-01-15 18:39:57 +0000519 TInfo, TyBeginLoc, Kind,
Anders Carlsson0aebc812009-09-09 21:33:21 +0000520 Exprs[0], RParenLoc));
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000521 }
522
Ted Kremenek6217b802009-07-29 21:53:49 +0000523 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Douglas Gregor506ae412009-01-16 18:33:17 +0000524 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
Sebastian Redlf53597f2009-03-15 17:47:39 +0000525
Mike Stump1eb44332009-09-09 15:08:12 +0000526 if (NumExprs > 1 || !Record->hasTrivialConstructor() ||
Anders Carlssone7624a72009-08-27 05:08:22 +0000527 !Record->hasTrivialDestructor()) {
Eli Friedman6997aae2010-01-31 20:58:15 +0000528 InitializedEntity Entity = InitializedEntity::InitializeTemporary(Ty);
529 InitializationKind Kind
530 = NumExprs ? InitializationKind::CreateDirect(TypeRange.getBegin(),
531 LParenLoc, RParenLoc)
532 : InitializationKind::CreateValue(TypeRange.getBegin(),
533 LParenLoc, RParenLoc);
534 InitializationSequence InitSeq(*this, Entity, Kind, Exprs, NumExprs);
535 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
536 move(exprs));
Douglas Gregor506ae412009-01-16 18:33:17 +0000537
Eli Friedman6997aae2010-01-31 20:58:15 +0000538 // FIXME: Improve AST representation?
539 return move(Result);
Douglas Gregor506ae412009-01-16 18:33:17 +0000540 }
541
542 // Fall through to value-initialize an object of class type that
543 // doesn't have a user-declared default constructor.
544 }
545
546 // C++ [expr.type.conv]p1:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000547 // If the expression list specifies more than a single value, the type shall
548 // be a class with a suitably declared constructor.
549 //
550 if (NumExprs > 1)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000551 return ExprError(Diag(CommaLocs[0],
552 diag::err_builtin_func_cast_more_than_one_arg)
553 << FullRange);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000554
555 assert(NumExprs == 0 && "Expected 0 expressions");
Douglas Gregor506ae412009-01-16 18:33:17 +0000556 // C++ [expr.type.conv]p2:
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000557 // The expression T(), where T is a simple-type-specifier for a non-array
558 // complete object type or the (possibly cv-qualified) void type, creates an
559 // rvalue of the specified type, which is value-initialized.
560 //
Sebastian Redlf53597f2009-03-15 17:47:39 +0000561 exprs.release();
562 return Owned(new (Context) CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc));
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +0000563}
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +0000564
565
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000566/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
567/// @code new (memory) int[size][4] @endcode
568/// or
569/// @code ::new Foo(23, "hello") @endcode
570/// For the interpretation of this heap of arguments, consult the base version.
Sebastian Redlf53597f2009-03-15 17:47:39 +0000571Action::OwningExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000572Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000573 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000574 SourceLocation PlacementRParen, bool ParenTypeId,
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000575 Declarator &D, SourceLocation ConstructorLParen,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000576 MultiExprArg ConstructorArgs,
Mike Stump1eb44332009-09-09 15:08:12 +0000577 SourceLocation ConstructorRParen) {
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000578 Expr *ArraySize = 0;
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000579 // If the specified type is an array, unwrap it and save the expression.
580 if (D.getNumTypeObjects() > 0 &&
581 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
582 DeclaratorChunk &Chunk = D.getTypeObject(0);
583 if (Chunk.Arr.hasStatic)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000584 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
585 << D.getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000586 if (!Chunk.Arr.NumElts)
Sebastian Redlf53597f2009-03-15 17:47:39 +0000587 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
588 << D.getSourceRange());
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000589
590 if (ParenTypeId) {
591 // Can't have dynamic array size when the type-id is in parentheses.
592 Expr *NumElts = (Expr *)Chunk.Arr.NumElts;
593 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
594 !NumElts->isIntegerConstantExpr(Context)) {
595 Diag(D.getTypeObject(0).Loc, diag::err_new_paren_array_nonconst)
596 << NumElts->getSourceRange();
597 return ExprError();
598 }
599 }
600
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000601 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000602 D.DropFirstTypeObject();
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000603 }
604
Douglas Gregor043cad22009-09-11 00:18:58 +0000605 // Every dimension shall be of constant size.
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000606 if (ArraySize) {
607 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
Douglas Gregor043cad22009-09-11 00:18:58 +0000608 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
609 break;
610
611 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
612 if (Expr *NumElts = (Expr *)Array.NumElts) {
613 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
614 !NumElts->isIntegerConstantExpr(Context)) {
615 Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst)
616 << NumElts->getSourceRange();
617 return ExprError();
618 }
619 }
620 }
621 }
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000622
John McCalla93c9342009-12-07 02:54:59 +0000623 //FIXME: Store TypeSourceInfo in CXXNew expression.
624 TypeSourceInfo *TInfo = 0;
625 QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, &TInfo);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000626 if (D.isInvalidType())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000627 return ExprError();
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000628
Mike Stump1eb44332009-09-09 15:08:12 +0000629 return BuildCXXNew(StartLoc, UseGlobal,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000630 PlacementLParen,
Mike Stump1eb44332009-09-09 15:08:12 +0000631 move(PlacementArgs),
Douglas Gregor3433cf72009-05-21 00:00:09 +0000632 PlacementRParen,
633 ParenTypeId,
Mike Stump1eb44332009-09-09 15:08:12 +0000634 AllocType,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000635 D.getSourceRange().getBegin(),
636 D.getSourceRange(),
637 Owned(ArraySize),
638 ConstructorLParen,
639 move(ConstructorArgs),
640 ConstructorRParen);
641}
642
Mike Stump1eb44332009-09-09 15:08:12 +0000643Sema::OwningExprResult
Douglas Gregor3433cf72009-05-21 00:00:09 +0000644Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
645 SourceLocation PlacementLParen,
646 MultiExprArg PlacementArgs,
647 SourceLocation PlacementRParen,
Mike Stump1eb44332009-09-09 15:08:12 +0000648 bool ParenTypeId,
Douglas Gregor3433cf72009-05-21 00:00:09 +0000649 QualType AllocType,
650 SourceLocation TypeLoc,
651 SourceRange TypeRange,
652 ExprArg ArraySizeE,
653 SourceLocation ConstructorLParen,
654 MultiExprArg ConstructorArgs,
655 SourceLocation ConstructorRParen) {
656 if (CheckAllocatedType(AllocType, TypeLoc, TypeRange))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000657 return ExprError();
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000658
Douglas Gregor3433cf72009-05-21 00:00:09 +0000659 QualType ResultType = Context.getPointerType(AllocType);
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000660
661 // That every array dimension except the first is constant was already
662 // checked by the type check above.
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000663
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000664 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
665 // or enumeration type with a non-negative value."
Douglas Gregor3433cf72009-05-21 00:00:09 +0000666 Expr *ArraySize = (Expr *)ArraySizeE.get();
Sebastian Redl28507842009-02-26 14:39:58 +0000667 if (ArraySize && !ArraySize->isTypeDependent()) {
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000668 QualType SizeType = ArraySize->getType();
669 if (!SizeType->isIntegralType() && !SizeType->isEnumeralType())
Sebastian Redlf53597f2009-03-15 17:47:39 +0000670 return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
671 diag::err_array_size_not_integral)
672 << SizeType << ArraySize->getSourceRange());
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000673 // Let's see if this is a constant < 0. If so, we reject it out of hand.
674 // We don't care about special rules, so we tell the machinery it's not
675 // evaluated - it gives us a result in more cases.
Sebastian Redl28507842009-02-26 14:39:58 +0000676 if (!ArraySize->isValueDependent()) {
677 llvm::APSInt Value;
678 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) {
679 if (Value < llvm::APSInt(
Anders Carlssonac18b2e2009-09-23 00:37:25 +0000680 llvm::APInt::getNullValue(Value.getBitWidth()),
681 Value.isUnsigned()))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000682 return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
683 diag::err_typecheck_negative_array_size)
684 << ArraySize->getSourceRange());
Sebastian Redl28507842009-02-26 14:39:58 +0000685 }
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000686 }
Anders Carlssonac18b2e2009-09-23 00:37:25 +0000687
Eli Friedman73c39ab2009-10-20 08:27:19 +0000688 ImpCastExprToType(ArraySize, Context.getSizeType(),
689 CastExpr::CK_IntegralCast);
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000690 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000691
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000692 FunctionDecl *OperatorNew = 0;
693 FunctionDecl *OperatorDelete = 0;
Sebastian Redlf53597f2009-03-15 17:47:39 +0000694 Expr **PlaceArgs = (Expr**)PlacementArgs.get();
695 unsigned NumPlaceArgs = PlacementArgs.size();
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000696
Sebastian Redl28507842009-02-26 14:39:58 +0000697 if (!AllocType->isDependentType() &&
698 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) &&
699 FindAllocationFunctions(StartLoc,
Sebastian Redl00e68e22009-02-09 18:24:27 +0000700 SourceRange(PlacementLParen, PlacementRParen),
701 UseGlobal, AllocType, ArraySize, PlaceArgs,
702 NumPlaceArgs, OperatorNew, OperatorDelete))
Sebastian Redlf53597f2009-03-15 17:47:39 +0000703 return ExprError();
Fariborz Jahanian048f52a2009-11-24 18:29:37 +0000704 llvm::SmallVector<Expr *, 8> AllPlaceArgs;
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000705 if (OperatorNew) {
706 // Add default arguments, if any.
707 const FunctionProtoType *Proto =
708 OperatorNew->getType()->getAs<FunctionProtoType>();
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +0000709 VariadicCallType CallType =
710 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
Fariborz Jahanian048f52a2009-11-24 18:29:37 +0000711 bool Invalid = GatherArgumentsForCall(PlacementLParen, OperatorNew,
712 Proto, 1, PlaceArgs, NumPlaceArgs,
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +0000713 AllPlaceArgs, CallType);
Fariborz Jahanian048f52a2009-11-24 18:29:37 +0000714 if (Invalid)
715 return ExprError();
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000716
Fariborz Jahanian498429f2009-11-19 18:39:40 +0000717 NumPlaceArgs = AllPlaceArgs.size();
718 if (NumPlaceArgs > 0)
719 PlaceArgs = &AllPlaceArgs[0];
720 }
721
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000722 bool Init = ConstructorLParen.isValid();
723 // --- Choosing a constructor ---
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000724 CXXConstructorDecl *Constructor = 0;
Sebastian Redlf53597f2009-03-15 17:47:39 +0000725 Expr **ConsArgs = (Expr**)ConstructorArgs.get();
726 unsigned NumConsArgs = ConstructorArgs.size();
Eli Friedmana8ce9ec2009-11-08 22:15:39 +0000727 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this);
728
Douglas Gregor99a2e602009-12-16 01:38:02 +0000729 if (!AllocType->isDependentType() &&
730 !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) {
731 // C++0x [expr.new]p15:
732 // A new-expression that creates an object of type T initializes that
733 // object as follows:
734 InitializationKind Kind
735 // - If the new-initializer is omitted, the object is default-
736 // initialized (8.5); if no initialization is performed,
737 // the object has indeterminate value
738 = !Init? InitializationKind::CreateDefault(TypeLoc)
739 // - Otherwise, the new-initializer is interpreted according to the
740 // initialization rules of 8.5 for direct-initialization.
741 : InitializationKind::CreateDirect(TypeLoc,
742 ConstructorLParen,
743 ConstructorRParen);
744
Douglas Gregor99a2e602009-12-16 01:38:02 +0000745 InitializedEntity Entity
Douglas Gregord6542d82009-12-22 15:35:07 +0000746 = InitializedEntity::InitializeNew(StartLoc, AllocType);
Douglas Gregor99a2e602009-12-16 01:38:02 +0000747 InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs);
Douglas Gregor99a2e602009-12-16 01:38:02 +0000748 OwningExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
749 move(ConstructorArgs));
750 if (FullInit.isInvalid())
751 return ExprError();
752
753 // FullInit is our initializer; walk through it to determine if it's a
754 // constructor call, which CXXNewExpr handles directly.
755 if (Expr *FullInitExpr = (Expr *)FullInit.get()) {
756 if (CXXBindTemporaryExpr *Binder
757 = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr))
758 FullInitExpr = Binder->getSubExpr();
759 if (CXXConstructExpr *Construct
760 = dyn_cast<CXXConstructExpr>(FullInitExpr)) {
761 Constructor = Construct->getConstructor();
762 for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(),
763 AEnd = Construct->arg_end();
764 A != AEnd; ++A)
765 ConvertedConstructorArgs.push_back(A->Retain());
766 } else {
767 // Take the converted initializer.
768 ConvertedConstructorArgs.push_back(FullInit.release());
769 }
770 } else {
771 // No initialization required.
772 }
773
774 // Take the converted arguments and use them for the new expression.
Douglas Gregor39da0b82009-09-09 23:08:42 +0000775 NumConsArgs = ConvertedConstructorArgs.size();
776 ConsArgs = (Expr **)ConvertedConstructorArgs.take();
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000777 }
Douglas Gregor99a2e602009-12-16 01:38:02 +0000778
Douglas Gregor6d908702010-02-26 05:06:18 +0000779 // Mark the new and delete operators as referenced.
780 if (OperatorNew)
781 MarkDeclarationReferenced(StartLoc, OperatorNew);
782 if (OperatorDelete)
783 MarkDeclarationReferenced(StartLoc, OperatorDelete);
784
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000785 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
Douglas Gregor089407b2009-10-17 21:40:42 +0000786
Sebastian Redlf53597f2009-03-15 17:47:39 +0000787 PlacementArgs.release();
788 ConstructorArgs.release();
Douglas Gregor3433cf72009-05-21 00:00:09 +0000789 ArraySizeE.release();
Ted Kremenekad7fe862010-02-11 22:51:03 +0000790 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew,
791 PlaceArgs, NumPlaceArgs, ParenTypeId,
792 ArraySize, Constructor, Init,
793 ConsArgs, NumConsArgs, OperatorDelete,
794 ResultType, StartLoc,
795 Init ? ConstructorRParen :
796 SourceLocation()));
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000797}
798
799/// CheckAllocatedType - Checks that a type is suitable as the allocated type
800/// in a new-expression.
801/// dimension off and stores the size expression in ArraySize.
Douglas Gregor3433cf72009-05-21 00:00:09 +0000802bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +0000803 SourceRange R) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000804 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
805 // abstract class type or array thereof.
Douglas Gregore7450f52009-03-24 19:52:54 +0000806 if (AllocType->isFunctionType())
Douglas Gregor3433cf72009-05-21 00:00:09 +0000807 return Diag(Loc, diag::err_bad_new_type)
808 << AllocType << 0 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +0000809 else if (AllocType->isReferenceType())
Douglas Gregor3433cf72009-05-21 00:00:09 +0000810 return Diag(Loc, diag::err_bad_new_type)
811 << AllocType << 1 << R;
Douglas Gregore7450f52009-03-24 19:52:54 +0000812 else if (!AllocType->isDependentType() &&
Douglas Gregor3433cf72009-05-21 00:00:09 +0000813 RequireCompleteType(Loc, AllocType,
Anders Carlssonb7906612009-08-26 23:45:07 +0000814 PDiag(diag::err_new_incomplete_type)
815 << R))
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000816 return true;
Douglas Gregor3433cf72009-05-21 00:00:09 +0000817 else if (RequireNonAbstractType(Loc, AllocType,
Douglas Gregore7450f52009-03-24 19:52:54 +0000818 diag::err_allocation_of_abstract_type))
819 return true;
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000820
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000821 return false;
822}
823
Douglas Gregor6d908702010-02-26 05:06:18 +0000824/// \brief Determine whether the given function is a non-placement
825/// deallocation function.
826static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) {
827 if (FD->isInvalidDecl())
828 return false;
829
830 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
831 return Method->isUsualDeallocationFunction();
832
833 return ((FD->getOverloadedOperator() == OO_Delete ||
834 FD->getOverloadedOperator() == OO_Array_Delete) &&
835 FD->getNumParams() == 1);
836}
837
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000838/// FindAllocationFunctions - Finds the overloads of operator new and delete
839/// that are appropriate for the allocation.
Sebastian Redl00e68e22009-02-09 18:24:27 +0000840bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
841 bool UseGlobal, QualType AllocType,
842 bool IsArray, Expr **PlaceArgs,
843 unsigned NumPlaceArgs,
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000844 FunctionDecl *&OperatorNew,
Mike Stump1eb44332009-09-09 15:08:12 +0000845 FunctionDecl *&OperatorDelete) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000846 // --- Choosing an allocation function ---
847 // C++ 5.3.4p8 - 14 & 18
848 // 1) If UseGlobal is true, only look in the global scope. Else, also look
849 // in the scope of the allocated class.
850 // 2) If an array size is given, look for operator new[], else look for
851 // operator new.
852 // 3) The first argument is always size_t. Append the arguments from the
853 // placement form.
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000854
855 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
856 // We don't care about the actual value of this argument.
857 // FIXME: Should the Sema create the expression and embed it in the syntax
858 // tree? Or should the consumer just recalculate the value?
Anders Carlssond67c4c32009-08-16 20:29:29 +0000859 IntegerLiteral Size(llvm::APInt::getNullValue(
860 Context.Target.getPointerWidth(0)),
861 Context.getSizeType(),
862 SourceLocation());
863 AllocArgs[0] = &Size;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000864 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
865
Douglas Gregor6d908702010-02-26 05:06:18 +0000866 // C++ [expr.new]p8:
867 // If the allocated type is a non-array type, the allocation
868 // function’s name is operator new and the deallocation function’s
869 // name is operator delete. If the allocated type is an array
870 // type, the allocation function’s name is operator new[] and the
871 // deallocation function’s name is operator delete[].
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000872 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
873 IsArray ? OO_Array_New : OO_New);
Douglas Gregor6d908702010-02-26 05:06:18 +0000874 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
875 IsArray ? OO_Array_Delete : OO_Delete);
876
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000877 if (AllocType->isRecordType() && !UseGlobal) {
Mike Stump1eb44332009-09-09 15:08:12 +0000878 CXXRecordDecl *Record
Ted Kremenek6217b802009-07-29 21:53:49 +0000879 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
Sebastian Redl00e68e22009-02-09 18:24:27 +0000880 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +0000881 AllocArgs.size(), Record, /*AllowMissing=*/true,
882 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000883 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000884 }
885 if (!OperatorNew) {
886 // Didn't find a member overload. Look for a global one.
887 DeclareGlobalNewDelete();
Sebastian Redl7f662392008-12-04 22:20:51 +0000888 DeclContext *TUDecl = Context.getTranslationUnitDecl();
Sebastian Redl00e68e22009-02-09 18:24:27 +0000889 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
Sebastian Redl7f662392008-12-04 22:20:51 +0000890 AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
891 OperatorNew))
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000892 return true;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000893 }
894
Anders Carlssond9583892009-05-31 20:26:12 +0000895 // FindAllocationOverload can change the passed in arguments, so we need to
896 // copy them back.
897 if (NumPlaceArgs > 0)
898 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
Mike Stump1eb44332009-09-09 15:08:12 +0000899
Douglas Gregor6d908702010-02-26 05:06:18 +0000900 // C++ [expr.new]p19:
901 //
902 // If the new-expression begins with a unary :: operator, the
903 // deallocation function’s name is looked up in the global
904 // scope. Otherwise, if the allocated type is a class type T or an
905 // array thereof, the deallocation function’s name is looked up in
906 // the scope of T. If this lookup fails to find the name, or if
907 // the allocated type is not a class type or array thereof, the
908 // deallocation function’s name is looked up in the global scope.
909 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
910 if (AllocType->isRecordType() && !UseGlobal) {
911 CXXRecordDecl *RD
912 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
913 LookupQualifiedName(FoundDelete, RD);
914 }
John McCall90c8c572010-03-18 08:19:33 +0000915 if (FoundDelete.isAmbiguous())
916 return true; // FIXME: clean up expressions?
Douglas Gregor6d908702010-02-26 05:06:18 +0000917
918 if (FoundDelete.empty()) {
919 DeclareGlobalNewDelete();
920 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
921 }
922
923 FoundDelete.suppressDiagnostics();
John McCall9aa472c2010-03-19 07:35:19 +0000924
925 llvm::SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
926
John McCall90c8c572010-03-18 08:19:33 +0000927 if (NumPlaceArgs > 0) {
Douglas Gregor6d908702010-02-26 05:06:18 +0000928 // C++ [expr.new]p20:
929 // A declaration of a placement deallocation function matches the
930 // declaration of a placement allocation function if it has the
931 // same number of parameters and, after parameter transformations
932 // (8.3.5), all parameter types except the first are
933 // identical. [...]
934 //
935 // To perform this comparison, we compute the function type that
936 // the deallocation function should have, and use that type both
937 // for template argument deduction and for comparison purposes.
938 QualType ExpectedFunctionType;
939 {
940 const FunctionProtoType *Proto
941 = OperatorNew->getType()->getAs<FunctionProtoType>();
942 llvm::SmallVector<QualType, 4> ArgTypes;
943 ArgTypes.push_back(Context.VoidPtrTy);
944 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I)
945 ArgTypes.push_back(Proto->getArgType(I));
946
947 ExpectedFunctionType
948 = Context.getFunctionType(Context.VoidTy, ArgTypes.data(),
949 ArgTypes.size(),
950 Proto->isVariadic(),
951 0, false, false, 0, 0, false, CC_Default);
952 }
953
954 for (LookupResult::iterator D = FoundDelete.begin(),
955 DEnd = FoundDelete.end();
956 D != DEnd; ++D) {
957 FunctionDecl *Fn = 0;
958 if (FunctionTemplateDecl *FnTmpl
959 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
960 // Perform template argument deduction to try to match the
961 // expected function type.
962 TemplateDeductionInfo Info(Context, StartLoc);
963 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info))
964 continue;
965 } else
966 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
967
968 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
John McCall9aa472c2010-03-19 07:35:19 +0000969 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +0000970 }
971 } else {
972 // C++ [expr.new]p20:
973 // [...] Any non-placement deallocation function matches a
974 // non-placement allocation function. [...]
975 for (LookupResult::iterator D = FoundDelete.begin(),
976 DEnd = FoundDelete.end();
977 D != DEnd; ++D) {
978 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
979 if (isNonPlacementDeallocationFunction(Fn))
John McCall9aa472c2010-03-19 07:35:19 +0000980 Matches.push_back(std::make_pair(D.getPair(), Fn));
Douglas Gregor6d908702010-02-26 05:06:18 +0000981 }
982 }
983
984 // C++ [expr.new]p20:
985 // [...] If the lookup finds a single matching deallocation
986 // function, that function will be called; otherwise, no
987 // deallocation function will be called.
988 if (Matches.size() == 1) {
John McCall9aa472c2010-03-19 07:35:19 +0000989 OperatorDelete = Matches[0].second;
Douglas Gregor6d908702010-02-26 05:06:18 +0000990
991 // C++0x [expr.new]p20:
992 // If the lookup finds the two-parameter form of a usual
993 // deallocation function (3.7.4.2) and that function, considered
994 // as a placement deallocation function, would have been
995 // selected as a match for the allocation function, the program
996 // is ill-formed.
997 if (NumPlaceArgs && getLangOptions().CPlusPlus0x &&
998 isNonPlacementDeallocationFunction(OperatorDelete)) {
999 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
1000 << SourceRange(PlaceArgs[0]->getLocStart(),
1001 PlaceArgs[NumPlaceArgs - 1]->getLocEnd());
1002 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1003 << DeleteName;
John McCall90c8c572010-03-18 08:19:33 +00001004 } else {
1005 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
John McCall9aa472c2010-03-19 07:35:19 +00001006 Matches[0].first);
Douglas Gregor6d908702010-02-26 05:06:18 +00001007 }
1008 }
1009
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001010 return false;
1011}
1012
Sebastian Redl7f662392008-12-04 22:20:51 +00001013/// FindAllocationOverload - Find an fitting overload for the allocation
1014/// function in the specified scope.
Sebastian Redl00e68e22009-02-09 18:24:27 +00001015bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1016 DeclarationName Name, Expr** Args,
1017 unsigned NumArgs, DeclContext *Ctx,
Mike Stump1eb44332009-09-09 15:08:12 +00001018 bool AllowMissing, FunctionDecl *&Operator) {
John McCalla24dc2e2009-11-17 02:14:36 +00001019 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1020 LookupQualifiedName(R, Ctx);
John McCallf36e02d2009-10-09 21:13:30 +00001021 if (R.empty()) {
Sebastian Redl7f662392008-12-04 22:20:51 +00001022 if (AllowMissing)
1023 return false;
Sebastian Redl7f662392008-12-04 22:20:51 +00001024 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
Chris Lattner4330d652009-02-17 07:29:20 +00001025 << Name << Range;
Sebastian Redl7f662392008-12-04 22:20:51 +00001026 }
1027
John McCall90c8c572010-03-18 08:19:33 +00001028 if (R.isAmbiguous())
1029 return true;
1030
1031 R.suppressDiagnostics();
John McCallf36e02d2009-10-09 21:13:30 +00001032
John McCall5769d612010-02-08 23:07:23 +00001033 OverloadCandidateSet Candidates(StartLoc);
Douglas Gregor5d64e5b2009-09-30 00:03:47 +00001034 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
1035 Alloc != AllocEnd; ++Alloc) {
Douglas Gregor3fc749d2008-12-23 00:26:44 +00001036 // Even member operator new/delete are implicitly treated as
1037 // static, so don't use AddMemberCandidate.
John McCall9aa472c2010-03-19 07:35:19 +00001038 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001039
John McCall9aa472c2010-03-19 07:35:19 +00001040 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1041 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001042 /*ExplicitTemplateArgs=*/0, Args, NumArgs,
1043 Candidates,
1044 /*SuppressUserConversions=*/false);
Douglas Gregor90916562009-09-29 18:16:17 +00001045 continue;
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001046 }
1047
John McCall9aa472c2010-03-19 07:35:19 +00001048 FunctionDecl *Fn = cast<FunctionDecl>(D);
1049 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates,
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001050 /*SuppressUserConversions=*/false);
Sebastian Redl7f662392008-12-04 22:20:51 +00001051 }
1052
1053 // Do the resolution.
1054 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00001055 switch(BestViableFunction(Candidates, StartLoc, Best)) {
Sebastian Redl7f662392008-12-04 22:20:51 +00001056 case OR_Success: {
1057 // Got one!
1058 FunctionDecl *FnDecl = Best->Function;
1059 // The first argument is size_t, and the first parameter must be size_t,
1060 // too. This is checked on declaration and can be assumed. (It can't be
1061 // asserted on, though, since invalid decls are left in there.)
John McCall90c8c572010-03-18 08:19:33 +00001062 // Watch out for variadic allocator function.
Fariborz Jahanian048f52a2009-11-24 18:29:37 +00001063 unsigned NumArgsInFnDecl = FnDecl->getNumParams();
1064 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001065 OwningExprResult Result
1066 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
1067 FnDecl->getParamDecl(i)),
1068 SourceLocation(),
1069 Owned(Args[i]->Retain()));
1070 if (Result.isInvalid())
Sebastian Redl7f662392008-12-04 22:20:51 +00001071 return true;
Douglas Gregor29ecaba2010-03-26 20:35:59 +00001072
1073 Args[i] = Result.takeAs<Expr>();
Sebastian Redl7f662392008-12-04 22:20:51 +00001074 }
1075 Operator = FnDecl;
John McCall9aa472c2010-03-19 07:35:19 +00001076 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl);
Sebastian Redl7f662392008-12-04 22:20:51 +00001077 return false;
1078 }
1079
1080 case OR_No_Viable_Function:
Sebastian Redl7f662392008-12-04 22:20:51 +00001081 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
Chris Lattner4330d652009-02-17 07:29:20 +00001082 << Name << Range;
John McCallcbce6062010-01-12 07:18:19 +00001083 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs);
Sebastian Redl7f662392008-12-04 22:20:51 +00001084 return true;
1085
1086 case OR_Ambiguous:
Sebastian Redl7f662392008-12-04 22:20:51 +00001087 Diag(StartLoc, diag::err_ovl_ambiguous_call)
Sebastian Redl00e68e22009-02-09 18:24:27 +00001088 << Name << Range;
John McCallcbce6062010-01-12 07:18:19 +00001089 PrintOverloadCandidates(Candidates, OCD_ViableCandidates, Args, NumArgs);
Sebastian Redl7f662392008-12-04 22:20:51 +00001090 return true;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001091
1092 case OR_Deleted:
1093 Diag(StartLoc, diag::err_ovl_deleted_call)
1094 << Best->Function->isDeleted()
1095 << Name << Range;
John McCallcbce6062010-01-12 07:18:19 +00001096 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001097 return true;
Sebastian Redl7f662392008-12-04 22:20:51 +00001098 }
1099 assert(false && "Unreachable, bad result from BestViableFunction");
1100 return true;
1101}
1102
1103
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001104/// DeclareGlobalNewDelete - Declare the global forms of operator new and
1105/// delete. These are:
1106/// @code
1107/// void* operator new(std::size_t) throw(std::bad_alloc);
1108/// void* operator new[](std::size_t) throw(std::bad_alloc);
1109/// void operator delete(void *) throw();
1110/// void operator delete[](void *) throw();
1111/// @endcode
1112/// Note that the placement and nothrow forms of new are *not* implicitly
1113/// declared. Their use requires including \<new\>.
Mike Stump1eb44332009-09-09 15:08:12 +00001114void Sema::DeclareGlobalNewDelete() {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001115 if (GlobalNewDeleteDeclared)
1116 return;
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001117
1118 // C++ [basic.std.dynamic]p2:
1119 // [...] The following allocation and deallocation functions (18.4) are
1120 // implicitly declared in global scope in each translation unit of a
1121 // program
1122 //
1123 // void* operator new(std::size_t) throw(std::bad_alloc);
1124 // void* operator new[](std::size_t) throw(std::bad_alloc);
1125 // void operator delete(void*) throw();
1126 // void operator delete[](void*) throw();
1127 //
1128 // These implicit declarations introduce only the function names operator
1129 // new, operator new[], operator delete, operator delete[].
1130 //
1131 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
1132 // "std" or "bad_alloc" as necessary to form the exception specification.
1133 // However, we do not make these implicit declarations visible to name
1134 // lookup.
1135 if (!StdNamespace) {
1136 // The "std" namespace has not yet been defined, so build one implicitly.
1137 StdNamespace = NamespaceDecl::Create(Context,
1138 Context.getTranslationUnitDecl(),
1139 SourceLocation(),
1140 &PP.getIdentifierTable().get("std"));
1141 StdNamespace->setImplicit(true);
1142 }
1143
1144 if (!StdBadAlloc) {
1145 // The "std::bad_alloc" class has not yet been declared, so build it
1146 // implicitly.
1147 StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class,
1148 StdNamespace,
1149 SourceLocation(),
1150 &PP.getIdentifierTable().get("bad_alloc"),
1151 SourceLocation(), 0);
1152 StdBadAlloc->setImplicit(true);
1153 }
1154
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001155 GlobalNewDeleteDeclared = true;
1156
1157 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
1158 QualType SizeT = Context.getSizeType();
Nuno Lopesfc284482009-12-16 16:59:22 +00001159 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew;
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001160
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001161 DeclareGlobalAllocationFunction(
1162 Context.DeclarationNames.getCXXOperatorName(OO_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001163 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001164 DeclareGlobalAllocationFunction(
1165 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
Nuno Lopesfc284482009-12-16 16:59:22 +00001166 VoidPtr, SizeT, AssumeSaneOperatorNew);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001167 DeclareGlobalAllocationFunction(
1168 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
1169 Context.VoidTy, VoidPtr);
1170 DeclareGlobalAllocationFunction(
1171 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
1172 Context.VoidTy, VoidPtr);
1173}
1174
1175/// DeclareGlobalAllocationFunction - Declares a single implicit global
1176/// allocation function if it doesn't already exist.
1177void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
Nuno Lopesfc284482009-12-16 16:59:22 +00001178 QualType Return, QualType Argument,
1179 bool AddMallocAttr) {
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001180 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
1181
1182 // Check if this function is already declared.
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001183 {
Douglas Gregor5cc37092008-12-23 22:05:29 +00001184 DeclContext::lookup_iterator Alloc, AllocEnd;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001185 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name);
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001186 Alloc != AllocEnd; ++Alloc) {
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001187 // Only look at non-template functions, as it is the predefined,
1188 // non-templated allocation function we are trying to declare here.
1189 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
1190 QualType InitialParamType =
Douglas Gregor6e790ab2009-12-22 23:42:49 +00001191 Context.getCanonicalType(
Chandler Carruth4a73ea92010-02-03 11:02:14 +00001192 Func->getParamDecl(0)->getType().getUnqualifiedType());
1193 // FIXME: Do we need to check for default arguments here?
1194 if (Func->getNumParams() == 1 && InitialParamType == Argument)
1195 return;
1196 }
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001197 }
1198 }
1199
Douglas Gregor7adb10f2009-09-15 22:30:29 +00001200 QualType BadAllocType;
1201 bool HasBadAllocExceptionSpec
1202 = (Name.getCXXOverloadedOperator() == OO_New ||
1203 Name.getCXXOverloadedOperator() == OO_Array_New);
1204 if (HasBadAllocExceptionSpec) {
1205 assert(StdBadAlloc && "Must have std::bad_alloc declared");
1206 BadAllocType = Context.getTypeDeclType(StdBadAlloc);
1207 }
1208
1209 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0,
1210 true, false,
1211 HasBadAllocExceptionSpec? 1 : 0,
Douglas Gregorce056bc2010-02-21 22:15:06 +00001212 &BadAllocType, false, CC_Default);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001213 FunctionDecl *Alloc =
1214 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name,
John McCalla93c9342009-12-07 02:54:59 +00001215 FnType, /*TInfo=*/0, FunctionDecl::None, false, true);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001216 Alloc->setImplicit();
Nuno Lopesfc284482009-12-16 16:59:22 +00001217
1218 if (AddMallocAttr)
1219 Alloc->addAttr(::new (Context) MallocAttr());
1220
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001221 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
John McCalla93c9342009-12-07 02:54:59 +00001222 0, Argument, /*TInfo=*/0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001223 VarDecl::None, 0);
Douglas Gregor838db382010-02-11 01:19:42 +00001224 Alloc->setParams(&Param, 1);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001225
Douglas Gregor6ed40e32008-12-23 21:05:05 +00001226 // FIXME: Also add this declaration to the IdentifierResolver, but
1227 // make sure it is at the end of the chain to coincide with the
1228 // global scope.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001229 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001230}
1231
Anders Carlsson78f74552009-11-15 18:45:20 +00001232bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
1233 DeclarationName Name,
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00001234 FunctionDecl* &Operator) {
John McCalla24dc2e2009-11-17 02:14:36 +00001235 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
Anders Carlsson78f74552009-11-15 18:45:20 +00001236 // Try to find operator delete/operator delete[] in class scope.
John McCalla24dc2e2009-11-17 02:14:36 +00001237 LookupQualifiedName(Found, RD);
Anders Carlsson78f74552009-11-15 18:45:20 +00001238
John McCalla24dc2e2009-11-17 02:14:36 +00001239 if (Found.isAmbiguous())
Anders Carlsson78f74552009-11-15 18:45:20 +00001240 return true;
Anders Carlsson78f74552009-11-15 18:45:20 +00001241
1242 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1243 F != FEnd; ++F) {
1244 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F))
1245 if (Delete->isUsualDeallocationFunction()) {
1246 Operator = Delete;
1247 return false;
1248 }
1249 }
1250
1251 // We did find operator delete/operator delete[] declarations, but
1252 // none of them were suitable.
1253 if (!Found.empty()) {
1254 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
1255 << Name << RD;
1256
1257 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1258 F != FEnd; ++F) {
1259 Diag((*F)->getLocation(),
1260 diag::note_delete_member_function_declared_here)
1261 << Name;
1262 }
1263
1264 return true;
1265 }
1266
1267 // Look for a global declaration.
1268 DeclareGlobalNewDelete();
1269 DeclContext *TUDecl = Context.getTranslationUnitDecl();
1270
1271 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation());
1272 Expr* DeallocArgs[1];
1273 DeallocArgs[0] = &Null;
1274 if (FindAllocationOverload(StartLoc, SourceRange(), Name,
1275 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false,
1276 Operator))
1277 return true;
1278
1279 assert(Operator && "Did not find a deallocation function!");
1280 return false;
1281}
1282
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001283/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
1284/// @code ::delete ptr; @endcode
1285/// or
1286/// @code delete [] ptr; @endcode
Sebastian Redlf53597f2009-03-15 17:47:39 +00001287Action::OwningExprResult
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001288Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
Mike Stump1eb44332009-09-09 15:08:12 +00001289 bool ArrayForm, ExprArg Operand) {
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001290 // C++ [expr.delete]p1:
1291 // The operand shall have a pointer type, or a class type having a single
1292 // conversion function to a pointer type. The result has type void.
1293 //
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001294 // DR599 amends "pointer type" to "pointer to object type" in both cases.
1295
Anders Carlssond67c4c32009-08-16 20:29:29 +00001296 FunctionDecl *OperatorDelete = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001297
Sebastian Redlf53597f2009-03-15 17:47:39 +00001298 Expr *Ex = (Expr *)Operand.get();
Sebastian Redl28507842009-02-26 14:39:58 +00001299 if (!Ex->isTypeDependent()) {
1300 QualType Type = Ex->getType();
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001301
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001302 if (const RecordType *Record = Type->getAs<RecordType>()) {
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001303 llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions;
Fariborz Jahanian53462782009-09-11 21:44:33 +00001304 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
John McCalleec51cf2010-01-20 00:46:10 +00001305 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions();
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001306
John McCalleec51cf2010-01-20 00:46:10 +00001307 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
John McCallba135432009-11-21 08:51:07 +00001308 E = Conversions->end(); I != E; ++I) {
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001309 // Skip over templated conversion functions; they aren't considered.
John McCallba135432009-11-21 08:51:07 +00001310 if (isa<FunctionTemplateDecl>(*I))
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001311 continue;
1312
John McCallba135432009-11-21 08:51:07 +00001313 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I);
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001314
1315 QualType ConvType = Conv->getConversionType().getNonReferenceType();
1316 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
1317 if (ConvPtrType->getPointeeType()->isObjectType())
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001318 ObjectPtrConversions.push_back(Conv);
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001319 }
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001320 if (ObjectPtrConversions.size() == 1) {
1321 // We have a single conversion to a pointer-to-object type. Perform
1322 // that conversion.
1323 Operand.release();
1324 if (!PerformImplicitConversion(Ex,
1325 ObjectPtrConversions.front()->getConversionType(),
Douglas Gregor68647482009-12-16 03:45:30 +00001326 AA_Converting)) {
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001327 Operand = Owned(Ex);
1328 Type = Ex->getType();
1329 }
1330 }
1331 else if (ObjectPtrConversions.size() > 1) {
1332 Diag(StartLoc, diag::err_ambiguous_delete_operand)
1333 << Type << Ex->getSourceRange();
1334 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) {
1335 CXXConversionDecl *Conv = ObjectPtrConversions[i];
John McCallb1622a12010-01-06 09:43:14 +00001336 NoteOverloadCandidate(Conv);
Fariborz Jahanian8b915e72009-09-15 22:15:23 +00001337 }
1338 return ExprError();
Douglas Gregor9cd9f3f2009-09-09 23:39:55 +00001339 }
Sebastian Redl28507842009-02-26 14:39:58 +00001340 }
1341
Sebastian Redlf53597f2009-03-15 17:47:39 +00001342 if (!Type->isPointerType())
1343 return ExprError(Diag(StartLoc, diag::err_delete_operand)
1344 << Type << Ex->getSourceRange());
Sebastian Redl28507842009-02-26 14:39:58 +00001345
Ted Kremenek6217b802009-07-29 21:53:49 +00001346 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
Douglas Gregor8dcb29d2009-03-24 20:13:58 +00001347 if (Pointee->isFunctionType() || Pointee->isVoidType())
Sebastian Redlf53597f2009-03-15 17:47:39 +00001348 return ExprError(Diag(StartLoc, diag::err_delete_operand)
1349 << Type << Ex->getSourceRange());
Douglas Gregor8dcb29d2009-03-24 20:13:58 +00001350 else if (!Pointee->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00001351 RequireCompleteType(StartLoc, Pointee,
Anders Carlssonb7906612009-08-26 23:45:07 +00001352 PDiag(diag::warn_delete_incomplete)
1353 << Ex->getSourceRange()))
Douglas Gregor8dcb29d2009-03-24 20:13:58 +00001354 return ExprError();
Sebastian Redl28507842009-02-26 14:39:58 +00001355
Douglas Gregor1070c9f2009-09-29 21:38:53 +00001356 // C++ [expr.delete]p2:
1357 // [Note: a pointer to a const type can be the operand of a
1358 // delete-expression; it is not necessary to cast away the constness
1359 // (5.2.11) of the pointer expression before it is used as the operand
1360 // of the delete-expression. ]
1361 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy),
1362 CastExpr::CK_NoOp);
1363
1364 // Update the operand.
1365 Operand.take();
1366 Operand = ExprArg(*this, Ex);
1367
Anders Carlssond67c4c32009-08-16 20:29:29 +00001368 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1369 ArrayForm ? OO_Array_Delete : OO_Delete);
1370
Anders Carlsson78f74552009-11-15 18:45:20 +00001371 if (const RecordType *RT = Pointee->getAs<RecordType>()) {
1372 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1373
1374 if (!UseGlobal &&
1375 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete))
Anders Carlsson0ba63ea2009-11-14 03:17:38 +00001376 return ExprError();
Anders Carlsson0ba63ea2009-11-14 03:17:38 +00001377
Anders Carlsson78f74552009-11-15 18:45:20 +00001378 if (!RD->hasTrivialDestructor())
1379 if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context))
Mike Stump1eb44332009-09-09 15:08:12 +00001380 MarkDeclarationReferenced(StartLoc,
Fariborz Jahanian34374e62009-09-03 23:18:17 +00001381 const_cast<CXXDestructorDecl*>(Dtor));
Anders Carlssond67c4c32009-08-16 20:29:29 +00001382 }
Anders Carlsson78f74552009-11-15 18:45:20 +00001383
Anders Carlssond67c4c32009-08-16 20:29:29 +00001384 if (!OperatorDelete) {
Anders Carlsson78f74552009-11-15 18:45:20 +00001385 // Look for a global declaration.
Anders Carlssond67c4c32009-08-16 20:29:29 +00001386 DeclareGlobalNewDelete();
1387 DeclContext *TUDecl = Context.getTranslationUnitDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001388 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName,
Douglas Gregor90916562009-09-29 18:16:17 +00001389 &Ex, 1, TUDecl, /*AllowMissing=*/false,
Anders Carlssond67c4c32009-08-16 20:29:29 +00001390 OperatorDelete))
1391 return ExprError();
1392 }
Mike Stump1eb44332009-09-09 15:08:12 +00001393
Sebastian Redl28507842009-02-26 14:39:58 +00001394 // FIXME: Check access and ambiguity of operator delete and destructor.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001395 }
1396
Sebastian Redlf53597f2009-03-15 17:47:39 +00001397 Operand.release();
1398 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
Anders Carlssond67c4c32009-08-16 20:29:29 +00001399 OperatorDelete, Ex, StartLoc));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001400}
1401
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001402/// \brief Check the use of the given variable as a C++ condition in an if,
1403/// while, do-while, or switch statement.
1404Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) {
1405 QualType T = ConditionVar->getType();
1406
1407 // C++ [stmt.select]p2:
1408 // The declarator shall not specify a function or an array.
1409 if (T->isFunctionType())
1410 return ExprError(Diag(ConditionVar->getLocation(),
1411 diag::err_invalid_use_of_function_type)
1412 << ConditionVar->getSourceRange());
1413 else if (T->isArrayType())
1414 return ExprError(Diag(ConditionVar->getLocation(),
1415 diag::err_invalid_use_of_array_type)
1416 << ConditionVar->getSourceRange());
Douglas Gregora7605db2009-11-24 16:07:02 +00001417
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001418 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar,
1419 ConditionVar->getLocation(),
1420 ConditionVar->getType().getNonReferenceType()));
1421}
1422
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001423/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
1424bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) {
1425 // C++ 6.4p4:
1426 // The value of a condition that is an initialized declaration in a statement
1427 // other than a switch statement is the value of the declared variable
1428 // implicitly converted to type bool. If that conversion is ill-formed, the
1429 // program is ill-formed.
1430 // The value of a condition that is an expression is the value of the
1431 // expression, implicitly converted to bool.
1432 //
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001433 return PerformContextuallyConvertToBool(CondExpr);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001434}
Douglas Gregor77a52232008-09-12 00:47:35 +00001435
1436/// Helper function to determine whether this is the (deprecated) C++
1437/// conversion from a string literal to a pointer to non-const char or
1438/// non-const wchar_t (for narrow and wide string literals,
1439/// respectively).
Mike Stump1eb44332009-09-09 15:08:12 +00001440bool
Douglas Gregor77a52232008-09-12 00:47:35 +00001441Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
1442 // Look inside the implicit cast, if it exists.
1443 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
1444 From = Cast->getSubExpr();
1445
1446 // A string literal (2.13.4) that is not a wide string literal can
1447 // be converted to an rvalue of type "pointer to char"; a wide
1448 // string literal can be converted to an rvalue of type "pointer
1449 // to wchar_t" (C++ 4.2p2).
1450 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From))
Ted Kremenek6217b802009-07-29 21:53:49 +00001451 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
Mike Stump1eb44332009-09-09 15:08:12 +00001452 if (const BuiltinType *ToPointeeType
John McCall183700f2009-09-21 23:43:11 +00001453 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
Douglas Gregor77a52232008-09-12 00:47:35 +00001454 // This conversion is considered only when there is an
1455 // explicit appropriate pointer target type (C++ 4.2p2).
John McCall0953e762009-09-24 19:53:00 +00001456 if (!ToPtrType->getPointeeType().hasQualifiers() &&
Douglas Gregor77a52232008-09-12 00:47:35 +00001457 ((StrLit->isWide() && ToPointeeType->isWideCharType()) ||
1458 (!StrLit->isWide() &&
1459 (ToPointeeType->getKind() == BuiltinType::Char_U ||
1460 ToPointeeType->getKind() == BuiltinType::Char_S))))
1461 return true;
1462 }
1463
1464 return false;
1465}
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001466
1467/// PerformImplicitConversion - Perform an implicit conversion of the
1468/// expression From to the type ToType. Returns true if there was an
1469/// error, false otherwise. The expression From is replaced with the
Douglas Gregor45920e82008-12-19 17:40:08 +00001470/// converted expression. Flavor is the kind of conversion we're
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001471/// performing, used in the error message. If @p AllowExplicit,
Sebastian Redle2b68332009-04-12 17:16:29 +00001472/// explicit user-defined conversions are permitted. @p Elidable should be true
1473/// when called for copies which may be elided (C++ 12.8p15). C++0x overload
1474/// resolution works differently in that case.
1475bool
Douglas Gregor45920e82008-12-19 17:40:08 +00001476Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor68647482009-12-16 03:45:30 +00001477 AssignmentAction Action, bool AllowExplicit,
Mike Stump1eb44332009-09-09 15:08:12 +00001478 bool Elidable) {
Sebastian Redle2b68332009-04-12 17:16:29 +00001479 ImplicitConversionSequence ICS;
Douglas Gregor68647482009-12-16 03:45:30 +00001480 return PerformImplicitConversion(From, ToType, Action, AllowExplicit,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00001481 Elidable, ICS);
1482}
1483
1484bool
1485Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor68647482009-12-16 03:45:30 +00001486 AssignmentAction Action, bool AllowExplicit,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00001487 bool Elidable,
1488 ImplicitConversionSequence& ICS) {
John McCallb1bdc622010-02-25 01:37:24 +00001489 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
Sebastian Redle2b68332009-04-12 17:16:29 +00001490 if (Elidable && getLangOptions().CPlusPlus0x) {
Mike Stump1eb44332009-09-09 15:08:12 +00001491 ICS = TryImplicitConversion(From, ToType,
Anders Carlssonda7a18b2009-08-27 17:24:15 +00001492 /*SuppressUserConversions=*/false,
Mike Stump1eb44332009-09-09 15:08:12 +00001493 AllowExplicit,
Anders Carlsson08972922009-08-28 15:33:32 +00001494 /*ForceRValue=*/true,
1495 /*InOverloadResolution=*/false);
Sebastian Redle2b68332009-04-12 17:16:29 +00001496 }
John McCall1d318332010-01-12 00:44:57 +00001497 if (ICS.isBad()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001498 ICS = TryImplicitConversion(From, ToType,
Anders Carlssonda7a18b2009-08-27 17:24:15 +00001499 /*SuppressUserConversions=*/false,
1500 AllowExplicit,
Anders Carlsson08972922009-08-28 15:33:32 +00001501 /*ForceRValue=*/false,
1502 /*InOverloadResolution=*/false);
Sebastian Redle2b68332009-04-12 17:16:29 +00001503 }
Douglas Gregor68647482009-12-16 03:45:30 +00001504 return PerformImplicitConversion(From, ToType, ICS, Action);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001505}
1506
1507/// PerformImplicitConversion - Perform an implicit conversion of the
1508/// expression From to the type ToType using the pre-computed implicit
1509/// conversion sequence ICS. Returns true if there was an error, false
1510/// otherwise. The expression From is replaced with the converted
Douglas Gregor68647482009-12-16 03:45:30 +00001511/// expression. Action is the kind of conversion we're performing,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00001512/// used in the error message.
1513bool
1514Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1515 const ImplicitConversionSequence &ICS,
Douglas Gregor68647482009-12-16 03:45:30 +00001516 AssignmentAction Action, bool IgnoreBaseAccess) {
John McCall1d318332010-01-12 00:44:57 +00001517 switch (ICS.getKind()) {
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001518 case ImplicitConversionSequence::StandardConversion:
Douglas Gregor68647482009-12-16 03:45:30 +00001519 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001520 IgnoreBaseAccess))
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001521 return true;
1522 break;
1523
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001524 case ImplicitConversionSequence::UserDefinedConversion: {
1525
Fariborz Jahanian7fe5d722009-08-28 22:04:50 +00001526 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
1527 CastExpr::CastKind CastKind = CastExpr::CK_Unknown;
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001528 QualType BeforeToType;
1529 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
Fariborz Jahanian7fe5d722009-08-28 22:04:50 +00001530 CastKind = CastExpr::CK_UserDefinedConversion;
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001531
1532 // If the user-defined conversion is specified by a conversion function,
1533 // the initial standard conversion sequence converts the source type to
1534 // the implicit object parameter of the conversion function.
1535 BeforeToType = Context.getTagDeclType(Conv->getParent());
1536 } else if (const CXXConstructorDecl *Ctor =
1537 dyn_cast<CXXConstructorDecl>(FD)) {
Anders Carlsson0aebc812009-09-09 21:33:21 +00001538 CastKind = CastExpr::CK_ConstructorConversion;
Fariborz Jahanian966256a2009-11-06 00:23:08 +00001539 // Do no conversion if dealing with ... for the first conversion.
Douglas Gregore44201a2009-11-20 02:31:03 +00001540 if (!ICS.UserDefined.EllipsisConversion) {
Fariborz Jahanian966256a2009-11-06 00:23:08 +00001541 // If the user-defined conversion is specified by a constructor, the
1542 // initial standard conversion sequence converts the source type to the
1543 // type required by the argument of the constructor
Douglas Gregore44201a2009-11-20 02:31:03 +00001544 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
1545 }
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001546 }
Anders Carlsson0aebc812009-09-09 21:33:21 +00001547 else
1548 assert(0 && "Unknown conversion function kind!");
Fariborz Jahanian966256a2009-11-06 00:23:08 +00001549 // Whatch out for elipsis conversion.
Fariborz Jahanian4c0cea22009-11-06 00:55:14 +00001550 if (!ICS.UserDefined.EllipsisConversion) {
Fariborz Jahanian966256a2009-11-06 00:23:08 +00001551 if (PerformImplicitConversion(From, BeforeToType,
Douglas Gregor68647482009-12-16 03:45:30 +00001552 ICS.UserDefined.Before, AA_Converting,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001553 IgnoreBaseAccess))
Fariborz Jahanian966256a2009-11-06 00:23:08 +00001554 return true;
1555 }
Anders Carlssonf6c213a2009-09-15 06:28:28 +00001556
Anders Carlsson0aebc812009-09-09 21:33:21 +00001557 OwningExprResult CastArg
1558 = BuildCXXCastArgument(From->getLocStart(),
1559 ToType.getNonReferenceType(),
1560 CastKind, cast<CXXMethodDecl>(FD),
1561 Owned(From));
1562
1563 if (CastArg.isInvalid())
1564 return true;
Eli Friedmand8889622009-11-27 04:41:50 +00001565
1566 From = CastArg.takeAs<Expr>();
1567
Eli Friedmand8889622009-11-27 04:41:50 +00001568 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
Douglas Gregor68647482009-12-16 03:45:30 +00001569 AA_Converting, IgnoreBaseAccess);
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00001570 }
John McCall1d318332010-01-12 00:44:57 +00001571
1572 case ImplicitConversionSequence::AmbiguousConversion:
1573 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(),
1574 PDiag(diag::err_typecheck_ambiguous_condition)
1575 << From->getSourceRange());
1576 return true;
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00001577
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001578 case ImplicitConversionSequence::EllipsisConversion:
1579 assert(false && "Cannot perform an ellipsis conversion");
Douglas Gregor60d62c22008-10-31 16:23:19 +00001580 return false;
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001581
1582 case ImplicitConversionSequence::BadConversion:
1583 return true;
1584 }
1585
1586 // Everything went well.
1587 return false;
1588}
1589
1590/// PerformImplicitConversion - Perform an implicit conversion of the
1591/// expression From to the type ToType by following the standard
1592/// conversion sequence SCS. Returns true if there was an error, false
1593/// otherwise. The expression From is replaced with the converted
Douglas Gregor45920e82008-12-19 17:40:08 +00001594/// expression. Flavor is the context in which we're performing this
1595/// conversion, for use in error messages.
Mike Stump1eb44332009-09-09 15:08:12 +00001596bool
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001597Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00001598 const StandardConversionSequence& SCS,
Douglas Gregor68647482009-12-16 03:45:30 +00001599 AssignmentAction Action, bool IgnoreBaseAccess) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001600 // Overall FIXME: we are recomputing too many types here and doing far too
1601 // much extra work. What this means is that we need to keep track of more
1602 // information that is computed when we try the implicit conversion initially,
1603 // so that we don't need to recompute anything here.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001604 QualType FromType = From->getType();
1605
Douglas Gregor225c41e2008-11-03 19:09:14 +00001606 if (SCS.CopyConstructor) {
Anders Carlsson7c3e8a12009-05-19 04:45:15 +00001607 // FIXME: When can ToType be a reference type?
1608 assert(!ToType->isReferenceType());
Fariborz Jahanianb3c47742009-09-25 18:59:21 +00001609 if (SCS.Second == ICK_Derived_To_Base) {
1610 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1611 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
1612 MultiExprArg(*this, (void **)&From, 1),
1613 /*FIXME:ConstructLoc*/SourceLocation(),
1614 ConstructorArgs))
1615 return true;
1616 OwningExprResult FromResult =
1617 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1618 ToType, SCS.CopyConstructor,
1619 move_arg(ConstructorArgs));
1620 if (FromResult.isInvalid())
1621 return true;
1622 From = FromResult.takeAs<Expr>();
1623 return false;
1624 }
Mike Stump1eb44332009-09-09 15:08:12 +00001625 OwningExprResult FromResult =
1626 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1627 ToType, SCS.CopyConstructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001628 MultiExprArg(*this, (void**)&From, 1));
Mike Stump1eb44332009-09-09 15:08:12 +00001629
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001630 if (FromResult.isInvalid())
1631 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001632
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001633 From = FromResult.takeAs<Expr>();
Douglas Gregor225c41e2008-11-03 19:09:14 +00001634 return false;
1635 }
1636
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001637 // Perform the first implicit conversion.
1638 switch (SCS.First) {
1639 case ICK_Identity:
1640 case ICK_Lvalue_To_Rvalue:
1641 // Nothing to do.
1642 break;
1643
1644 case ICK_Array_To_Pointer:
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001645 FromType = Context.getArrayDecayedType(FromType);
Anders Carlsson82495762009-08-08 21:04:35 +00001646 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay);
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001647 break;
1648
1649 case ICK_Function_To_Pointer:
Douglas Gregor063daf62009-03-13 18:40:31 +00001650 if (Context.getCanonicalType(FromType) == Context.OverloadTy) {
Douglas Gregor904eed32008-11-10 20:40:00 +00001651 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true);
1652 if (!Fn)
1653 return true;
1654
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001655 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
1656 return true;
1657
Anders Carlsson96ad5332009-10-21 17:16:23 +00001658 From = FixOverloadedFunctionReference(From, Fn);
Douglas Gregor904eed32008-11-10 20:40:00 +00001659 FromType = From->getType();
Anders Carlsson96ad5332009-10-21 17:16:23 +00001660
Sebastian Redl759986e2009-10-17 20:50:27 +00001661 // If there's already an address-of operator in the expression, we have
1662 // the right type already, and the code below would just introduce an
1663 // invalid additional pointer level.
Anders Carlsson96ad5332009-10-21 17:16:23 +00001664 if (FromType->isPointerType() || FromType->isMemberFunctionPointerType())
Sebastian Redl759986e2009-10-17 20:50:27 +00001665 break;
Douglas Gregor904eed32008-11-10 20:40:00 +00001666 }
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001667 FromType = Context.getPointerType(FromType);
Anders Carlssonb633c4e2009-09-01 20:37:18 +00001668 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001669 break;
1670
1671 default:
1672 assert(false && "Improper first standard conversion");
1673 break;
1674 }
1675
1676 // Perform the second implicit conversion
1677 switch (SCS.Second) {
1678 case ICK_Identity:
Sebastian Redl2c7588f2009-10-10 12:04:10 +00001679 // If both sides are functions (or pointers/references to them), there could
1680 // be incompatible exception declarations.
1681 if (CheckExceptionSpecCompatibility(From, ToType))
1682 return true;
1683 // Nothing else to do.
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001684 break;
1685
Douglas Gregor43c79c22009-12-09 00:47:37 +00001686 case ICK_NoReturn_Adjustment:
1687 // If both sides are functions (or pointers/references to them), there could
1688 // be incompatible exception declarations.
1689 if (CheckExceptionSpecCompatibility(From, ToType))
1690 return true;
1691
1692 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false),
1693 CastExpr::CK_NoOp);
1694 break;
1695
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001696 case ICK_Integral_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001697 case ICK_Integral_Conversion:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001698 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast);
1699 break;
1700
1701 case ICK_Floating_Promotion:
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001702 case ICK_Floating_Conversion:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001703 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast);
1704 break;
1705
1706 case ICK_Complex_Promotion:
Douglas Gregor5cdf8212009-02-12 00:15:05 +00001707 case ICK_Complex_Conversion:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001708 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1709 break;
1710
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001711 case ICK_Floating_Integral:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001712 if (ToType->isFloatingType())
1713 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating);
1714 else
1715 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral);
1716 break;
1717
Douglas Gregor5cdf8212009-02-12 00:15:05 +00001718 case ICK_Complex_Real:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001719 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1720 break;
1721
Douglas Gregorf9201e02009-02-11 23:02:49 +00001722 case ICK_Compatible_Conversion:
Eli Friedman73c39ab2009-10-20 08:27:19 +00001723 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001724 break;
1725
Anders Carlsson61faec12009-09-12 04:46:44 +00001726 case ICK_Pointer_Conversion: {
Douglas Gregor45920e82008-12-19 17:40:08 +00001727 if (SCS.IncompatibleObjC) {
1728 // Diagnose incompatible Objective-C conversions
Mike Stump1eb44332009-09-09 15:08:12 +00001729 Diag(From->getSourceRange().getBegin(),
Douglas Gregor45920e82008-12-19 17:40:08 +00001730 diag::ext_typecheck_convert_incompatible_pointer)
Douglas Gregor68647482009-12-16 03:45:30 +00001731 << From->getType() << ToType << Action
Douglas Gregor45920e82008-12-19 17:40:08 +00001732 << From->getSourceRange();
1733 }
1734
Anders Carlsson61faec12009-09-12 04:46:44 +00001735
1736 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001737 if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess))
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001738 return true;
Anders Carlsson61faec12009-09-12 04:46:44 +00001739 ImpCastExprToType(From, ToType, Kind);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001740 break;
Anders Carlsson61faec12009-09-12 04:46:44 +00001741 }
1742
1743 case ICK_Pointer_Member: {
1744 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001745 if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess))
Anders Carlsson61faec12009-09-12 04:46:44 +00001746 return true;
Sebastian Redl2c7588f2009-10-10 12:04:10 +00001747 if (CheckExceptionSpecCompatibility(From, ToType))
1748 return true;
Anders Carlsson61faec12009-09-12 04:46:44 +00001749 ImpCastExprToType(From, ToType, Kind);
1750 break;
1751 }
Anders Carlssonbc0e0782009-11-23 20:04:44 +00001752 case ICK_Boolean_Conversion: {
1753 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1754 if (FromType->isMemberPointerType())
1755 Kind = CastExpr::CK_MemberPointerToBoolean;
1756
1757 ImpCastExprToType(From, Context.BoolTy, Kind);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001758 break;
Anders Carlssonbc0e0782009-11-23 20:04:44 +00001759 }
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001760
Douglas Gregorb7a86f52009-11-06 01:02:41 +00001761 case ICK_Derived_To_Base:
1762 if (CheckDerivedToBaseConversion(From->getType(),
1763 ToType.getNonReferenceType(),
1764 From->getLocStart(),
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001765 From->getSourceRange(),
1766 IgnoreBaseAccess))
Douglas Gregorb7a86f52009-11-06 01:02:41 +00001767 return true;
1768 ImpCastExprToType(From, ToType.getNonReferenceType(),
1769 CastExpr::CK_DerivedToBase);
1770 break;
1771
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001772 default:
1773 assert(false && "Improper second standard conversion");
1774 break;
1775 }
1776
1777 switch (SCS.Third) {
1778 case ICK_Identity:
1779 // Nothing to do.
1780 break;
1781
1782 case ICK_Qualification:
Mike Stump390b4cc2009-05-16 07:39:55 +00001783 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue
1784 // references.
Mike Stump1eb44332009-09-09 15:08:12 +00001785 ImpCastExprToType(From, ToType.getNonReferenceType(),
Eli Friedman73c39ab2009-10-20 08:27:19 +00001786 CastExpr::CK_NoOp,
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001787 ToType->isLValueReferenceType());
Douglas Gregora9bff302010-02-28 18:30:25 +00001788
1789 if (SCS.DeprecatedStringLiteralToCharPtr)
1790 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion)
1791 << ToType.getNonReferenceType();
1792
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001793 break;
Douglas Gregorb7a86f52009-11-06 01:02:41 +00001794
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001795 default:
1796 assert(false && "Improper second standard conversion");
1797 break;
1798 }
1799
1800 return false;
1801}
1802
Sebastian Redl64b45f72009-01-05 20:52:13 +00001803Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1804 SourceLocation KWLoc,
1805 SourceLocation LParen,
1806 TypeTy *Ty,
1807 SourceLocation RParen) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00001808 QualType T = GetTypeFromParser(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001809
Anders Carlsson3292d5c2009-07-07 19:06:02 +00001810 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
1811 // all traits except __is_class, __is_enum and __is_union require a the type
1812 // to be complete.
1813 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) {
Mike Stump1eb44332009-09-09 15:08:12 +00001814 if (RequireCompleteType(KWLoc, T,
Anders Carlssond497ba72009-08-26 22:59:12 +00001815 diag::err_incomplete_type_used_in_type_trait_expr))
Anders Carlsson3292d5c2009-07-07 19:06:02 +00001816 return ExprError();
1817 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00001818
1819 // There is no point in eagerly computing the value. The traits are designed
1820 // to be used from type trait templates, so Ty will be a template parameter
1821 // 99% of the time.
Anders Carlsson3292d5c2009-07-07 19:06:02 +00001822 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T,
1823 RParen, Context.BoolTy));
Sebastian Redl64b45f72009-01-05 20:52:13 +00001824}
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001825
1826QualType Sema::CheckPointerToMemberOperands(
Mike Stump1eb44332009-09-09 15:08:12 +00001827 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) {
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001828 const char *OpSpelling = isIndirect ? "->*" : ".*";
1829 // C++ 5.5p2
1830 // The binary operator .* [p3: ->*] binds its second operand, which shall
1831 // be of type "pointer to member of T" (where T is a completely-defined
1832 // class type) [...]
1833 QualType RType = rex->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00001834 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
Douglas Gregore7450f52009-03-24 19:52:54 +00001835 if (!MemPtr) {
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001836 Diag(Loc, diag::err_bad_memptr_rhs)
1837 << OpSpelling << RType << rex->getSourceRange();
1838 return QualType();
Mike Stump1eb44332009-09-09 15:08:12 +00001839 }
Douglas Gregore7450f52009-03-24 19:52:54 +00001840
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001841 QualType Class(MemPtr->getClass(), 0);
1842
1843 // C++ 5.5p2
1844 // [...] to its first operand, which shall be of class T or of a class of
1845 // which T is an unambiguous and accessible base class. [p3: a pointer to
1846 // such a class]
1847 QualType LType = lex->getType();
1848 if (isIndirect) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001849 if (const PointerType *Ptr = LType->getAs<PointerType>())
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001850 LType = Ptr->getPointeeType().getNonReferenceType();
1851 else {
1852 Diag(Loc, diag::err_bad_memptr_lhs)
Fariborz Jahanianef78ac62009-10-26 20:45:27 +00001853 << OpSpelling << 1 << LType
1854 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ".*");
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001855 return QualType();
1856 }
1857 }
1858
Douglas Gregora4923eb2009-11-16 21:35:15 +00001859 if (!Context.hasSameUnqualifiedType(Class, LType)) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001860 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
1861 /*DetectVirtual=*/false);
Mike Stump390b4cc2009-05-16 07:39:55 +00001862 // FIXME: Would it be useful to print full ambiguity paths, or is that
1863 // overkill?
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001864 if (!IsDerivedFrom(LType, Class, Paths) ||
1865 Paths.isAmbiguous(Context.getCanonicalType(Class))) {
1866 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
Eli Friedman3005efe2010-01-16 00:00:48 +00001867 << (int)isIndirect << lex->getType();
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001868 return QualType();
1869 }
Eli Friedman3005efe2010-01-16 00:00:48 +00001870 // Cast LHS to type of use.
1871 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
1872 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid;
1873 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001874 }
1875
Fariborz Jahanian19d70732009-11-18 22:16:17 +00001876 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) {
Fariborz Jahanian05ebda92009-11-18 21:54:48 +00001877 // Diagnose use of pointer-to-member type which when used as
1878 // the functional cast in a pointer-to-member expression.
1879 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
1880 return QualType();
1881 }
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001882 // C++ 5.5p2
1883 // The result is an object or a function of the type specified by the
1884 // second operand.
1885 // The cv qualifiers are the union of those in the pointer and the left side,
1886 // in accordance with 5.5p5 and 5.2.5.
1887 // FIXME: This returns a dereferenced member function pointer as a normal
1888 // function type. However, the only operation valid on such functions is
Mike Stump390b4cc2009-05-16 07:39:55 +00001889 // calling them. There's also a GCC extension to get a function pointer to the
1890 // thing, which is another complication, because this type - unlike the type
1891 // that is the result of this expression - takes the class as the first
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001892 // argument.
1893 // We probably need a "MemberFunctionClosureType" or something like that.
1894 QualType Result = MemPtr->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00001895 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers());
Sebastian Redl7c8bd602009-02-07 20:10:22 +00001896 return Result;
1897}
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001898
1899/// \brief Get the target type of a standard or user-defined conversion.
1900static QualType TargetType(const ImplicitConversionSequence &ICS) {
John McCall1d318332010-01-12 00:44:57 +00001901 switch (ICS.getKind()) {
1902 case ImplicitConversionSequence::StandardConversion:
Douglas Gregorad323a82010-01-27 03:51:04 +00001903 return ICS.Standard.getToType(2);
John McCall1d318332010-01-12 00:44:57 +00001904 case ImplicitConversionSequence::UserDefinedConversion:
Douglas Gregorad323a82010-01-27 03:51:04 +00001905 return ICS.UserDefined.After.getToType(2);
John McCall1d318332010-01-12 00:44:57 +00001906 case ImplicitConversionSequence::AmbiguousConversion:
1907 return ICS.Ambiguous.getToType();
John McCallb1bdc622010-02-25 01:37:24 +00001908
John McCall1d318332010-01-12 00:44:57 +00001909 case ImplicitConversionSequence::EllipsisConversion:
1910 case ImplicitConversionSequence::BadConversion:
1911 llvm_unreachable("function not valid for ellipsis or bad conversions");
1912 }
1913 return QualType(); // silence warnings
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001914}
1915
1916/// \brief Try to convert a type to another according to C++0x 5.16p3.
1917///
1918/// This is part of the parameter validation for the ? operator. If either
1919/// value operand is a class type, the two operands are attempted to be
1920/// converted to each other. This function does the conversion in one direction.
Douglas Gregorb70cf442010-03-26 20:14:36 +00001921/// It returns true if the program is ill-formed and has already been diagnosed
1922/// as such.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001923static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
1924 SourceLocation QuestionLoc,
Douglas Gregorb70cf442010-03-26 20:14:36 +00001925 bool &HaveConversion,
1926 QualType &ToType) {
1927 HaveConversion = false;
1928 ToType = To->getType();
1929
1930 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
1931 SourceLocation());
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001932 // C++0x 5.16p3
1933 // The process for determining whether an operand expression E1 of type T1
1934 // can be converted to match an operand expression E2 of type T2 is defined
1935 // as follows:
1936 // -- If E2 is an lvalue:
1937 if (To->isLvalue(Self.Context) == Expr::LV_Valid) {
1938 // E1 can be converted to match E2 if E1 can be implicitly converted to
1939 // type "lvalue reference to T2", subject to the constraint that in the
1940 // conversion the reference must bind directly to E1.
Douglas Gregorb70cf442010-03-26 20:14:36 +00001941 QualType T = Self.Context.getLValueReferenceType(ToType);
1942 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
1943
1944 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
1945 if (InitSeq.isDirectReferenceBinding()) {
1946 ToType = T;
1947 HaveConversion = true;
1948 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001949 }
Douglas Gregorb70cf442010-03-26 20:14:36 +00001950
1951 if (InitSeq.isAmbiguous())
1952 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001953 }
John McCallb1bdc622010-02-25 01:37:24 +00001954
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001955 // -- If E2 is an rvalue, or if the conversion above cannot be done:
1956 // -- if E1 and E2 have class type, and the underlying class types are
1957 // the same or one is a base class of the other:
1958 QualType FTy = From->getType();
1959 QualType TTy = To->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00001960 const RecordType *FRec = FTy->getAs<RecordType>();
1961 const RecordType *TRec = TTy->getAs<RecordType>();
Douglas Gregorb70cf442010-03-26 20:14:36 +00001962 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
1963 Self.IsDerivedFrom(FTy, TTy);
1964 if (FRec && TRec &&
1965 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001966 // E1 can be converted to match E2 if the class of T2 is the
1967 // same type as, or a base class of, the class of T1, and
1968 // [cv2 > cv1].
John McCallb1bdc622010-02-25 01:37:24 +00001969 if (FRec == TRec || FDerivedFromT) {
1970 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00001971 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
1972 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
1973 if (InitSeq.getKind() != InitializationSequence::FailedSequence) {
1974 HaveConversion = true;
1975 return false;
1976 }
1977
1978 if (InitSeq.isAmbiguous())
1979 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
1980 }
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001981 }
Douglas Gregorb70cf442010-03-26 20:14:36 +00001982
1983 return false;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00001984 }
Douglas Gregorb70cf442010-03-26 20:14:36 +00001985
1986 // -- Otherwise: E1 can be converted to match E2 if E1 can be
1987 // implicitly converted to the type that expression E2 would have
1988 // if E2 were converted to an rvalue.
1989 // First find the decayed type.
1990 if (TTy->isFunctionType())
1991 TTy = Self.Context.getPointerType(TTy);
1992 else if (TTy->isArrayType())
1993 TTy = Self.Context.getArrayDecayedType(TTy);
1994
1995 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
1996 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
1997 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence;
1998 ToType = TTy;
1999 if (InitSeq.isAmbiguous())
2000 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
2001
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002002 return false;
2003}
2004
2005/// \brief Try to find a common type for two according to C++0x 5.16p5.
2006///
2007/// This is part of the parameter validation for the ? operator. If either
2008/// value operand is a class type, overload resolution is used to find a
2009/// conversion to a common type.
2010static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS,
2011 SourceLocation Loc) {
2012 Expr *Args[2] = { LHS, RHS };
John McCall5769d612010-02-08 23:07:23 +00002013 OverloadCandidateSet CandidateSet(Loc);
Douglas Gregor573d9c32009-10-21 23:19:44 +00002014 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002015
2016 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00002017 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002018 case OR_Success:
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002019 // We found a match. Perform the conversions on the arguments and move on.
2020 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0],
Douglas Gregor68647482009-12-16 03:45:30 +00002021 Best->Conversions[0], Sema::AA_Converting) ||
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002022 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1],
Douglas Gregor68647482009-12-16 03:45:30 +00002023 Best->Conversions[1], Sema::AA_Converting))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002024 break;
2025 return false;
2026
Douglas Gregor20093b42009-12-09 23:02:17 +00002027 case OR_No_Viable_Function:
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002028 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
2029 << LHS->getType() << RHS->getType()
2030 << LHS->getSourceRange() << RHS->getSourceRange();
2031 return true;
2032
Douglas Gregor20093b42009-12-09 23:02:17 +00002033 case OR_Ambiguous:
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002034 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl)
2035 << LHS->getType() << RHS->getType()
2036 << LHS->getSourceRange() << RHS->getSourceRange();
Mike Stump390b4cc2009-05-16 07:39:55 +00002037 // FIXME: Print the possible common types by printing the return types of
2038 // the viable candidates.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002039 break;
2040
Douglas Gregor20093b42009-12-09 23:02:17 +00002041 case OR_Deleted:
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002042 assert(false && "Conditional operator has only built-in overloads");
2043 break;
2044 }
2045 return true;
2046}
2047
Sebastian Redl76458502009-04-17 16:30:52 +00002048/// \brief Perform an "extended" implicit conversion as returned by
2049/// TryClassUnification.
Douglas Gregorb70cf442010-03-26 20:14:36 +00002050static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) {
2051 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
2052 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(),
2053 SourceLocation());
2054 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1);
2055 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind,
2056 Sema::MultiExprArg(Self, (void **)&E, 1));
2057 if (Result.isInvalid())
Sebastian Redl76458502009-04-17 16:30:52 +00002058 return true;
Douglas Gregorb70cf442010-03-26 20:14:36 +00002059
2060 E = Result.takeAs<Expr>();
Sebastian Redl76458502009-04-17 16:30:52 +00002061 return false;
2062}
2063
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002064/// \brief Check the operands of ?: under C++ semantics.
2065///
2066/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
2067/// extension. In this case, LHS == Cond. (But they're not aliases.)
2068QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
2069 SourceLocation QuestionLoc) {
Mike Stump390b4cc2009-05-16 07:39:55 +00002070 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
2071 // interface pointers.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002072
2073 // C++0x 5.16p1
2074 // The first expression is contextually converted to bool.
2075 if (!Cond->isTypeDependent()) {
2076 if (CheckCXXBooleanCondition(Cond))
2077 return QualType();
2078 }
2079
2080 // Either of the arguments dependent?
2081 if (LHS->isTypeDependent() || RHS->isTypeDependent())
2082 return Context.DependentTy;
2083
John McCalld1b47bf2010-03-11 19:43:18 +00002084 CheckSignCompare(LHS, RHS, QuestionLoc);
John McCallb13c87f2009-11-05 09:23:39 +00002085
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002086 // C++0x 5.16p2
2087 // If either the second or the third operand has type (cv) void, ...
2088 QualType LTy = LHS->getType();
2089 QualType RTy = RHS->getType();
2090 bool LVoid = LTy->isVoidType();
2091 bool RVoid = RTy->isVoidType();
2092 if (LVoid || RVoid) {
2093 // ... then the [l2r] conversions are performed on the second and third
2094 // operands ...
Douglas Gregora873dfc2010-02-03 00:27:59 +00002095 DefaultFunctionArrayLvalueConversion(LHS);
2096 DefaultFunctionArrayLvalueConversion(RHS);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002097 LTy = LHS->getType();
2098 RTy = RHS->getType();
2099
2100 // ... and one of the following shall hold:
2101 // -- The second or the third operand (but not both) is a throw-
2102 // expression; the result is of the type of the other and is an rvalue.
2103 bool LThrow = isa<CXXThrowExpr>(LHS);
2104 bool RThrow = isa<CXXThrowExpr>(RHS);
2105 if (LThrow && !RThrow)
2106 return RTy;
2107 if (RThrow && !LThrow)
2108 return LTy;
2109
2110 // -- Both the second and third operands have type void; the result is of
2111 // type void and is an rvalue.
2112 if (LVoid && RVoid)
2113 return Context.VoidTy;
2114
2115 // Neither holds, error.
2116 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
2117 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
2118 << LHS->getSourceRange() << RHS->getSourceRange();
2119 return QualType();
2120 }
2121
2122 // Neither is void.
2123
2124 // C++0x 5.16p3
2125 // Otherwise, if the second and third operand have different types, and
2126 // either has (cv) class type, and attempt is made to convert each of those
2127 // operands to the other.
Douglas Gregorb70cf442010-03-26 20:14:36 +00002128 if (!Context.hasSameType(LTy, RTy) &&
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002129 (LTy->isRecordType() || RTy->isRecordType())) {
2130 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
2131 // These return true if a single direction is already ambiguous.
Douglas Gregorb70cf442010-03-26 20:14:36 +00002132 QualType L2RType, R2LType;
2133 bool HaveL2R, HaveR2L;
2134 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002135 return QualType();
Douglas Gregorb70cf442010-03-26 20:14:36 +00002136 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002137 return QualType();
Douglas Gregorb70cf442010-03-26 20:14:36 +00002138
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002139 // If both can be converted, [...] the program is ill-formed.
2140 if (HaveL2R && HaveR2L) {
2141 Diag(QuestionLoc, diag::err_conditional_ambiguous)
2142 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange();
2143 return QualType();
2144 }
2145
2146 // If exactly one conversion is possible, that conversion is applied to
2147 // the chosen operand and the converted operands are used in place of the
2148 // original operands for the remainder of this section.
2149 if (HaveL2R) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00002150 if (ConvertForConditional(*this, LHS, L2RType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002151 return QualType();
2152 LTy = LHS->getType();
2153 } else if (HaveR2L) {
Douglas Gregorb70cf442010-03-26 20:14:36 +00002154 if (ConvertForConditional(*this, RHS, R2LType))
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002155 return QualType();
2156 RTy = RHS->getType();
2157 }
2158 }
2159
2160 // C++0x 5.16p4
2161 // If the second and third operands are lvalues and have the same type,
2162 // the result is of that type [...]
2163 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy);
2164 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid &&
2165 RHS->isLvalue(Context) == Expr::LV_Valid)
2166 return LTy;
2167
2168 // C++0x 5.16p5
2169 // Otherwise, the result is an rvalue. If the second and third operands
2170 // do not have the same type, and either has (cv) class type, ...
2171 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
2172 // ... overload resolution is used to determine the conversions (if any)
2173 // to be applied to the operands. If the overload resolution fails, the
2174 // program is ill-formed.
2175 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
2176 return QualType();
2177 }
2178
2179 // C++0x 5.16p6
2180 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
2181 // conversions are performed on the second and third operands.
Douglas Gregora873dfc2010-02-03 00:27:59 +00002182 DefaultFunctionArrayLvalueConversion(LHS);
2183 DefaultFunctionArrayLvalueConversion(RHS);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002184 LTy = LHS->getType();
2185 RTy = RHS->getType();
2186
2187 // After those conversions, one of the following shall hold:
2188 // -- The second and third operands have the same type; the result
2189 // is of that type.
2190 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy))
2191 return LTy;
2192
2193 // -- The second and third operands have arithmetic or enumeration type;
2194 // the usual arithmetic conversions are performed to bring them to a
2195 // common type, and the result is of that type.
2196 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
2197 UsualArithmeticConversions(LHS, RHS);
2198 return LHS->getType();
2199 }
2200
2201 // -- The second and third operands have pointer type, or one has pointer
2202 // type and the other is a null pointer constant; pointer conversions
2203 // and qualification conversions are performed to bring them to their
2204 // composite pointer type. The result is of the composite pointer type.
Eli Friedmande8ac492010-01-02 22:56:07 +00002205 // -- The second and third operands have pointer to member type, or one has
2206 // pointer to member type and the other is a null pointer constant;
2207 // pointer to member conversions and qualification conversions are
2208 // performed to bring them to a common type, whose cv-qualification
2209 // shall match the cv-qualification of either the second or the third
2210 // operand. The result is of the common type.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002211 bool NonStandardCompositeType = false;
2212 QualType Composite = FindCompositePointerType(LHS, RHS,
2213 isSFINAEContext()? 0 : &NonStandardCompositeType);
2214 if (!Composite.isNull()) {
2215 if (NonStandardCompositeType)
2216 Diag(QuestionLoc,
2217 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
2218 << LTy << RTy << Composite
2219 << LHS->getSourceRange() << RHS->getSourceRange();
2220
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002221 return Composite;
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002222 }
Fariborz Jahanian55016362009-12-10 20:46:08 +00002223
2224 // Similarly, attempt to find composite type of twp objective-c pointers.
2225 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
2226 if (!Composite.isNull())
2227 return Composite;
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002228
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002229 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
2230 << LHS->getType() << RHS->getType()
2231 << LHS->getSourceRange() << RHS->getSourceRange();
2232 return QualType();
2233}
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002234
2235/// \brief Find a merged pointer type and convert the two expressions to it.
2236///
Douglas Gregor20b3e992009-08-24 17:42:35 +00002237/// This finds the composite pointer type (or member pointer type) for @p E1
2238/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this
2239/// type and returns it.
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002240/// It does not emit diagnostics.
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002241///
2242/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
2243/// a non-standard (but still sane) composite type to which both expressions
2244/// can be converted. When such a type is chosen, \c *NonStandardCompositeType
2245/// will be set true.
2246QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2,
2247 bool *NonStandardCompositeType) {
2248 if (NonStandardCompositeType)
2249 *NonStandardCompositeType = false;
2250
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002251 assert(getLangOptions().CPlusPlus && "This function assumes C++");
2252 QualType T1 = E1->getType(), T2 = E2->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00002253
Fariborz Jahanian0cedfbd2009-12-08 20:04:24 +00002254 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
2255 !T2->isAnyPointerType() && !T2->isMemberPointerType())
Douglas Gregor20b3e992009-08-24 17:42:35 +00002256 return QualType();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002257
2258 // C++0x 5.9p2
2259 // Pointer conversions and qualification conversions are performed on
2260 // pointer operands to bring them to their composite pointer type. If
2261 // one operand is a null pointer constant, the composite pointer type is
2262 // the type of the other operand.
Douglas Gregorce940492009-09-25 04:25:58 +00002263 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00002264 if (T2->isMemberPointerType())
2265 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer);
2266 else
2267 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002268 return T2;
2269 }
Douglas Gregorce940492009-09-25 04:25:58 +00002270 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00002271 if (T1->isMemberPointerType())
2272 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer);
2273 else
2274 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002275 return T1;
2276 }
Mike Stump1eb44332009-09-09 15:08:12 +00002277
Douglas Gregor20b3e992009-08-24 17:42:35 +00002278 // Now both have to be pointers or member pointers.
Sebastian Redla439e6f2009-11-16 21:03:45 +00002279 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
2280 (!T2->isPointerType() && !T2->isMemberPointerType()))
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002281 return QualType();
2282
2283 // Otherwise, of one of the operands has type "pointer to cv1 void," then
2284 // the other has type "pointer to cv2 T" and the composite pointer type is
2285 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
2286 // Otherwise, the composite pointer type is a pointer type similar to the
2287 // type of one of the operands, with a cv-qualification signature that is
2288 // the union of the cv-qualification signatures of the operand types.
2289 // In practice, the first part here is redundant; it's subsumed by the second.
2290 // What we do here is, we build the two possible composite types, and try the
2291 // conversions in both directions. If only one works, or if the two composite
2292 // types are the same, we have succeeded.
John McCall0953e762009-09-24 19:53:00 +00002293 // FIXME: extended qualifiers?
Sebastian Redla439e6f2009-11-16 21:03:45 +00002294 typedef llvm::SmallVector<unsigned, 4> QualifierVector;
2295 QualifierVector QualifierUnion;
2296 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4>
2297 ContainingClassVector;
2298 ContainingClassVector MemberOfClass;
2299 QualType Composite1 = Context.getCanonicalType(T1),
2300 Composite2 = Context.getCanonicalType(T2);
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002301 unsigned NeedConstBefore = 0;
Douglas Gregor20b3e992009-08-24 17:42:35 +00002302 do {
2303 const PointerType *Ptr1, *Ptr2;
2304 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
2305 (Ptr2 = Composite2->getAs<PointerType>())) {
2306 Composite1 = Ptr1->getPointeeType();
2307 Composite2 = Ptr2->getPointeeType();
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002308
2309 // If we're allowed to create a non-standard composite type, keep track
2310 // of where we need to fill in additional 'const' qualifiers.
2311 if (NonStandardCompositeType &&
2312 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
2313 NeedConstBefore = QualifierUnion.size();
2314
Douglas Gregor20b3e992009-08-24 17:42:35 +00002315 QualifierUnion.push_back(
2316 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
2317 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0));
2318 continue;
2319 }
Mike Stump1eb44332009-09-09 15:08:12 +00002320
Douglas Gregor20b3e992009-08-24 17:42:35 +00002321 const MemberPointerType *MemPtr1, *MemPtr2;
2322 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
2323 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
2324 Composite1 = MemPtr1->getPointeeType();
2325 Composite2 = MemPtr2->getPointeeType();
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002326
2327 // If we're allowed to create a non-standard composite type, keep track
2328 // of where we need to fill in additional 'const' qualifiers.
2329 if (NonStandardCompositeType &&
2330 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
2331 NeedConstBefore = QualifierUnion.size();
2332
Douglas Gregor20b3e992009-08-24 17:42:35 +00002333 QualifierUnion.push_back(
2334 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
2335 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
2336 MemPtr2->getClass()));
2337 continue;
2338 }
Mike Stump1eb44332009-09-09 15:08:12 +00002339
Douglas Gregor20b3e992009-08-24 17:42:35 +00002340 // FIXME: block pointer types?
Mike Stump1eb44332009-09-09 15:08:12 +00002341
Douglas Gregor20b3e992009-08-24 17:42:35 +00002342 // Cannot unwrap any more types.
2343 break;
2344 } while (true);
Mike Stump1eb44332009-09-09 15:08:12 +00002345
Douglas Gregorb2cb1cb2010-02-25 22:29:57 +00002346 if (NeedConstBefore && NonStandardCompositeType) {
2347 // Extension: Add 'const' to qualifiers that come before the first qualifier
2348 // mismatch, so that our (non-standard!) composite type meets the
2349 // requirements of C++ [conv.qual]p4 bullet 3.
2350 for (unsigned I = 0; I != NeedConstBefore; ++I) {
2351 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
2352 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
2353 *NonStandardCompositeType = true;
2354 }
2355 }
2356 }
2357
Douglas Gregor20b3e992009-08-24 17:42:35 +00002358 // Rewrap the composites as pointers or member pointers with the union CVRs.
Sebastian Redla439e6f2009-11-16 21:03:45 +00002359 ContainingClassVector::reverse_iterator MOC
2360 = MemberOfClass.rbegin();
2361 for (QualifierVector::reverse_iterator
2362 I = QualifierUnion.rbegin(),
2363 E = QualifierUnion.rend();
Douglas Gregor20b3e992009-08-24 17:42:35 +00002364 I != E; (void)++I, ++MOC) {
John McCall0953e762009-09-24 19:53:00 +00002365 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
Douglas Gregor20b3e992009-08-24 17:42:35 +00002366 if (MOC->first && MOC->second) {
2367 // Rebuild member pointer type
John McCall0953e762009-09-24 19:53:00 +00002368 Composite1 = Context.getMemberPointerType(
2369 Context.getQualifiedType(Composite1, Quals),
2370 MOC->first);
2371 Composite2 = Context.getMemberPointerType(
2372 Context.getQualifiedType(Composite2, Quals),
2373 MOC->second);
Douglas Gregor20b3e992009-08-24 17:42:35 +00002374 } else {
2375 // Rebuild pointer type
John McCall0953e762009-09-24 19:53:00 +00002376 Composite1
2377 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
2378 Composite2
2379 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
Douglas Gregor20b3e992009-08-24 17:42:35 +00002380 }
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002381 }
2382
Mike Stump1eb44332009-09-09 15:08:12 +00002383 ImplicitConversionSequence E1ToC1 =
Anders Carlssonda7a18b2009-08-27 17:24:15 +00002384 TryImplicitConversion(E1, Composite1,
2385 /*SuppressUserConversions=*/false,
2386 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00002387 /*ForceRValue=*/false,
2388 /*InOverloadResolution=*/false);
Mike Stump1eb44332009-09-09 15:08:12 +00002389 ImplicitConversionSequence E2ToC1 =
Anders Carlssonda7a18b2009-08-27 17:24:15 +00002390 TryImplicitConversion(E2, Composite1,
2391 /*SuppressUserConversions=*/false,
2392 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00002393 /*ForceRValue=*/false,
2394 /*InOverloadResolution=*/false);
Mike Stump1eb44332009-09-09 15:08:12 +00002395
John McCallb1bdc622010-02-25 01:37:24 +00002396 bool ToC2Viable = false;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002397 ImplicitConversionSequence E1ToC2, E2ToC2;
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002398 if (Context.getCanonicalType(Composite1) !=
2399 Context.getCanonicalType(Composite2)) {
Anders Carlssonda7a18b2009-08-27 17:24:15 +00002400 E1ToC2 = TryImplicitConversion(E1, Composite2,
2401 /*SuppressUserConversions=*/false,
2402 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00002403 /*ForceRValue=*/false,
2404 /*InOverloadResolution=*/false);
Anders Carlssonda7a18b2009-08-27 17:24:15 +00002405 E2ToC2 = TryImplicitConversion(E2, Composite2,
2406 /*SuppressUserConversions=*/false,
2407 /*AllowExplicit=*/false,
Anders Carlsson08972922009-08-28 15:33:32 +00002408 /*ForceRValue=*/false,
2409 /*InOverloadResolution=*/false);
John McCallb1bdc622010-02-25 01:37:24 +00002410 ToC2Viable = !E1ToC2.isBad() && !E2ToC2.isBad();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002411 }
2412
John McCall1d318332010-01-12 00:44:57 +00002413 bool ToC1Viable = !E1ToC1.isBad() && !E2ToC1.isBad();
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002414 if (ToC1Viable && !ToC2Viable) {
Douglas Gregor68647482009-12-16 03:45:30 +00002415 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, Sema::AA_Converting) &&
2416 !PerformImplicitConversion(E2, Composite1, E2ToC1, Sema::AA_Converting))
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002417 return Composite1;
2418 }
2419 if (ToC2Viable && !ToC1Viable) {
Douglas Gregor68647482009-12-16 03:45:30 +00002420 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, Sema::AA_Converting) &&
2421 !PerformImplicitConversion(E2, Composite2, E2ToC2, Sema::AA_Converting))
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002422 return Composite2;
2423 }
2424 return QualType();
2425}
Anders Carlsson165a0a02009-05-17 18:41:29 +00002426
Anders Carlssondef11992009-05-30 20:36:53 +00002427Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) {
Anders Carlsson089c2602009-08-15 23:41:35 +00002428 if (!Context.getLangOptions().CPlusPlus)
2429 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +00002430
Douglas Gregor51326552009-12-24 18:51:59 +00002431 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
2432
Ted Kremenek6217b802009-07-29 21:53:49 +00002433 const RecordType *RT = E->getType()->getAs<RecordType>();
Anders Carlssondef11992009-05-30 20:36:53 +00002434 if (!RT)
2435 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +00002436
John McCall86ff3082010-02-04 22:26:26 +00002437 // If this is the result of a call expression, our source might
2438 // actually be a reference, in which case we shouldn't bind.
Anders Carlsson283e4d52009-09-14 01:30:44 +00002439 if (CallExpr *CE = dyn_cast<CallExpr>(E)) {
2440 QualType Ty = CE->getCallee()->getType();
2441 if (const PointerType *PT = Ty->getAs<PointerType>())
2442 Ty = PT->getPointeeType();
Fariborz Jahanianb372b0f2010-02-18 20:31:02 +00002443 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>())
2444 Ty = BPT->getPointeeType();
2445
John McCall183700f2009-09-21 23:43:11 +00002446 const FunctionType *FTy = Ty->getAs<FunctionType>();
Anders Carlsson283e4d52009-09-14 01:30:44 +00002447 if (FTy->getResultType()->isReferenceType())
2448 return Owned(E);
2449 }
John McCall86ff3082010-02-04 22:26:26 +00002450
2451 // That should be enough to guarantee that this type is complete.
2452 // If it has a trivial destructor, we can avoid the extra copy.
2453 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
2454 if (RD->hasTrivialDestructor())
2455 return Owned(E);
2456
Mike Stump1eb44332009-09-09 15:08:12 +00002457 CXXTemporary *Temp = CXXTemporary::Create(Context,
Anders Carlssondef11992009-05-30 20:36:53 +00002458 RD->getDestructor(Context));
Anders Carlsson860306e2009-05-30 21:21:49 +00002459 ExprTemporaries.push_back(Temp);
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00002460 if (CXXDestructorDecl *Destructor =
2461 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context)))
2462 MarkDeclarationReferenced(E->getExprLoc(), Destructor);
Anders Carlssondef11992009-05-30 20:36:53 +00002463 // FIXME: Add the temporary to the temporaries vector.
2464 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
2465}
2466
Anders Carlsson0ece4912009-12-15 20:51:39 +00002467Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) {
Anders Carlsson99ba36d2009-06-05 15:38:08 +00002468 assert(SubExpr && "sub expression can't be null!");
Mike Stump1eb44332009-09-09 15:08:12 +00002469
Douglas Gregor1f5f3a42009-12-03 17:10:37 +00002470 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2471 assert(ExprTemporaries.size() >= FirstTemporary);
2472 if (ExprTemporaries.size() == FirstTemporary)
Anders Carlsson99ba36d2009-06-05 15:38:08 +00002473 return SubExpr;
Mike Stump1eb44332009-09-09 15:08:12 +00002474
Anders Carlsson99ba36d2009-06-05 15:38:08 +00002475 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr,
Douglas Gregor1f5f3a42009-12-03 17:10:37 +00002476 &ExprTemporaries[FirstTemporary],
Anders Carlsson0ece4912009-12-15 20:51:39 +00002477 ExprTemporaries.size() - FirstTemporary);
Douglas Gregor1f5f3a42009-12-03 17:10:37 +00002478 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2479 ExprTemporaries.end());
Mike Stump1eb44332009-09-09 15:08:12 +00002480
Anders Carlsson99ba36d2009-06-05 15:38:08 +00002481 return E;
2482}
2483
Douglas Gregor90f93822009-12-22 22:17:25 +00002484Sema::OwningExprResult
2485Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) {
2486 if (SubExpr.isInvalid())
2487 return ExprError();
2488
2489 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>()));
2490}
2491
Anders Carlsson5ee56e92009-12-16 02:09:40 +00002492FullExpr Sema::CreateFullExpr(Expr *SubExpr) {
2493 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2494 assert(ExprTemporaries.size() >= FirstTemporary);
2495
2496 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary;
2497 CXXTemporary **Temporaries =
2498 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary];
2499
2500 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries);
2501
2502 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2503 ExprTemporaries.end());
2504
2505 return E;
2506}
2507
Mike Stump1eb44332009-09-09 15:08:12 +00002508Sema::OwningExprResult
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002509Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc,
Douglas Gregord4dca082010-02-24 18:44:31 +00002510 tok::TokenKind OpKind, TypeTy *&ObjectType,
2511 bool &MayBePseudoDestructor) {
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002512 // Since this might be a postfix expression, get rid of ParenListExprs.
2513 Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
Mike Stump1eb44332009-09-09 15:08:12 +00002514
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002515 Expr *BaseExpr = (Expr*)Base.get();
2516 assert(BaseExpr && "no record expansion");
Mike Stump1eb44332009-09-09 15:08:12 +00002517
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002518 QualType BaseType = BaseExpr->getType();
Douglas Gregord4dca082010-02-24 18:44:31 +00002519 MayBePseudoDestructor = false;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002520 if (BaseType->isDependentType()) {
Douglas Gregor43d88632009-11-04 22:49:18 +00002521 // If we have a pointer to a dependent type and are using the -> operator,
2522 // the object type is the type that the pointer points to. We might still
2523 // have enough information about that type to do something useful.
2524 if (OpKind == tok::arrow)
2525 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
2526 BaseType = Ptr->getPointeeType();
2527
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002528 ObjectType = BaseType.getAsOpaquePtr();
Douglas Gregord4dca082010-02-24 18:44:31 +00002529 MayBePseudoDestructor = true;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002530 return move(Base);
2531 }
Mike Stump1eb44332009-09-09 15:08:12 +00002532
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002533 // C++ [over.match.oper]p8:
Mike Stump1eb44332009-09-09 15:08:12 +00002534 // [...] When operator->returns, the operator-> is applied to the value
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002535 // returned, with the original second operand.
2536 if (OpKind == tok::arrow) {
John McCallc4e83212009-09-30 01:01:30 +00002537 // The set of types we've considered so far.
John McCall432887f2009-09-30 01:30:54 +00002538 llvm::SmallPtrSet<CanQualType,8> CTypes;
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00002539 llvm::SmallVector<SourceLocation, 8> Locations;
John McCall432887f2009-09-30 01:30:54 +00002540 CTypes.insert(Context.getCanonicalType(BaseType));
John McCallc4e83212009-09-30 01:01:30 +00002541
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002542 while (BaseType->isRecordType()) {
Anders Carlsson15ea3782009-10-13 22:43:21 +00002543 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc);
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002544 BaseExpr = (Expr*)Base.get();
2545 if (BaseExpr == NULL)
2546 return ExprError();
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00002547 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr))
Anders Carlssonde699e52009-10-13 22:55:59 +00002548 Locations.push_back(OpCall->getDirectCallee()->getLocation());
John McCallc4e83212009-09-30 01:01:30 +00002549 BaseType = BaseExpr->getType();
2550 CanQualType CBaseType = Context.getCanonicalType(BaseType);
John McCall432887f2009-09-30 01:30:54 +00002551 if (!CTypes.insert(CBaseType)) {
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00002552 Diag(OpLoc, diag::err_operator_arrow_circular);
Fariborz Jahanian7a8233a2009-09-30 17:46:20 +00002553 for (unsigned i = 0; i < Locations.size(); i++)
2554 Diag(Locations[i], diag::note_declared_at);
Fariborz Jahanian4a4e3452009-09-30 00:19:41 +00002555 return ExprError();
2556 }
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002557 }
Mike Stump1eb44332009-09-09 15:08:12 +00002558
Douglas Gregor31658df2009-11-20 19:58:21 +00002559 if (BaseType->isPointerType())
2560 BaseType = BaseType->getPointeeType();
2561 }
Mike Stump1eb44332009-09-09 15:08:12 +00002562
2563 // We could end up with various non-record types here, such as extended
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002564 // vector types or Objective-C interfaces. Just return early and let
2565 // ActOnMemberReferenceExpr do the work.
Douglas Gregorc68afe22009-09-03 21:38:09 +00002566 if (!BaseType->isRecordType()) {
2567 // C++ [basic.lookup.classref]p2:
2568 // [...] If the type of the object expression is of pointer to scalar
2569 // type, the unqualified-id is looked up in the context of the complete
2570 // postfix-expression.
Douglas Gregord4dca082010-02-24 18:44:31 +00002571 //
2572 // This also indicates that we should be parsing a
2573 // pseudo-destructor-name.
Douglas Gregorc68afe22009-09-03 21:38:09 +00002574 ObjectType = 0;
Douglas Gregord4dca082010-02-24 18:44:31 +00002575 MayBePseudoDestructor = true;
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002576 return move(Base);
Douglas Gregorc68afe22009-09-03 21:38:09 +00002577 }
Mike Stump1eb44332009-09-09 15:08:12 +00002578
Douglas Gregor03c57052009-11-17 05:17:33 +00002579 // The object type must be complete (or dependent).
2580 if (!BaseType->isDependentType() &&
2581 RequireCompleteType(OpLoc, BaseType,
2582 PDiag(diag::err_incomplete_member_access)))
2583 return ExprError();
2584
Douglas Gregorc68afe22009-09-03 21:38:09 +00002585 // C++ [basic.lookup.classref]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00002586 // If the id-expression in a class member access (5.2.5) is an
Douglas Gregor03c57052009-11-17 05:17:33 +00002587 // unqualified-id, and the type of the object expression is of a class
Douglas Gregorc68afe22009-09-03 21:38:09 +00002588 // type C (or of pointer to a class type C), the unqualified-id is looked
2589 // up in the scope of class C. [...]
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002590 ObjectType = BaseType.getAsOpaquePtr();
Mike Stump1eb44332009-09-09 15:08:12 +00002591 return move(Base);
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002592}
2593
Douglas Gregor77549082010-02-24 21:29:12 +00002594Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc,
2595 ExprArg MemExpr) {
2596 Expr *E = (Expr *) MemExpr.get();
2597 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc);
2598 Diag(E->getLocStart(), diag::err_dtor_expr_without_call)
2599 << isa<CXXPseudoDestructorExpr>(E)
2600 << CodeModificationHint::CreateInsertion(ExpectedLParenLoc, "()");
2601
2602 return ActOnCallExpr(/*Scope*/ 0,
2603 move(MemExpr),
2604 /*LPLoc*/ ExpectedLParenLoc,
2605 Sema::MultiExprArg(*this, 0, 0),
2606 /*CommaLocs*/ 0,
2607 /*RPLoc*/ ExpectedLParenLoc);
2608}
Douglas Gregord4dca082010-02-24 18:44:31 +00002609
Douglas Gregorb57fb492010-02-24 22:38:50 +00002610Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base,
2611 SourceLocation OpLoc,
2612 tok::TokenKind OpKind,
2613 const CXXScopeSpec &SS,
Douglas Gregor26d4ac92010-02-24 23:40:28 +00002614 TypeSourceInfo *ScopeTypeInfo,
Douglas Gregorb57fb492010-02-24 22:38:50 +00002615 SourceLocation CCLoc,
Douglas Gregorfce46ee2010-02-24 23:50:37 +00002616 SourceLocation TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002617 PseudoDestructorTypeStorage Destructed,
Douglas Gregorb57fb492010-02-24 22:38:50 +00002618 bool HasTrailingLParen) {
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002619 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
Douglas Gregorb57fb492010-02-24 22:38:50 +00002620
2621 // C++ [expr.pseudo]p2:
2622 // The left-hand side of the dot operator shall be of scalar type. The
2623 // left-hand side of the arrow operator shall be of pointer to scalar type.
2624 // This scalar type is the object type.
2625 Expr *BaseE = (Expr *)Base.get();
2626 QualType ObjectType = BaseE->getType();
2627 if (OpKind == tok::arrow) {
2628 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
2629 ObjectType = Ptr->getPointeeType();
2630 } else if (!BaseE->isTypeDependent()) {
2631 // The user wrote "p->" when she probably meant "p."; fix it.
2632 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
2633 << ObjectType << true
2634 << CodeModificationHint::CreateReplacement(OpLoc, ".");
2635 if (isSFINAEContext())
2636 return ExprError();
2637
2638 OpKind = tok::period;
2639 }
2640 }
2641
2642 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) {
2643 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
2644 << ObjectType << BaseE->getSourceRange();
2645 return ExprError();
2646 }
2647
2648 // C++ [expr.pseudo]p2:
2649 // [...] The cv-unqualified versions of the object type and of the type
2650 // designated by the pseudo-destructor-name shall be the same type.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002651 if (DestructedTypeInfo) {
2652 QualType DestructedType = DestructedTypeInfo->getType();
2653 SourceLocation DestructedTypeStart
2654 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin();
2655 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() &&
2656 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
2657 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
2658 << ObjectType << DestructedType << BaseE->getSourceRange()
2659 << DestructedTypeInfo->getTypeLoc().getSourceRange();
2660
2661 // Recover by setting the destructed type to the object type.
2662 DestructedType = ObjectType;
2663 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
2664 DestructedTypeStart);
2665 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
2666 }
Douglas Gregorb57fb492010-02-24 22:38:50 +00002667 }
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002668
Douglas Gregorb57fb492010-02-24 22:38:50 +00002669 // C++ [expr.pseudo]p2:
2670 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
2671 // form
2672 //
2673 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
2674 //
2675 // shall designate the same scalar type.
2676 if (ScopeTypeInfo) {
2677 QualType ScopeType = ScopeTypeInfo->getType();
2678 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
2679 !Context.hasSameType(ScopeType, ObjectType)) {
2680
2681 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(),
2682 diag::err_pseudo_dtor_type_mismatch)
2683 << ObjectType << ScopeType << BaseE->getSourceRange()
2684 << ScopeTypeInfo->getTypeLoc().getSourceRange();
2685
2686 ScopeType = QualType();
2687 ScopeTypeInfo = 0;
2688 }
2689 }
2690
2691 OwningExprResult Result
2692 = Owned(new (Context) CXXPseudoDestructorExpr(Context,
2693 Base.takeAs<Expr>(),
2694 OpKind == tok::arrow,
2695 OpLoc,
2696 (NestedNameSpecifier *) SS.getScopeRep(),
2697 SS.getRange(),
2698 ScopeTypeInfo,
2699 CCLoc,
Douglas Gregorfce46ee2010-02-24 23:50:37 +00002700 TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002701 Destructed));
2702
Douglas Gregorb57fb492010-02-24 22:38:50 +00002703 if (HasTrailingLParen)
2704 return move(Result);
2705
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002706 return DiagnoseDtorReference(Destructed.getLocation(), move(Result));
Douglas Gregor77549082010-02-24 21:29:12 +00002707}
2708
2709Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
2710 SourceLocation OpLoc,
2711 tok::TokenKind OpKind,
2712 const CXXScopeSpec &SS,
2713 UnqualifiedId &FirstTypeName,
2714 SourceLocation CCLoc,
2715 SourceLocation TildeLoc,
2716 UnqualifiedId &SecondTypeName,
2717 bool HasTrailingLParen) {
2718 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2719 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
2720 "Invalid first type name in pseudo-destructor");
2721 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2722 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
2723 "Invalid second type name in pseudo-destructor");
2724
2725 Expr *BaseE = (Expr *)Base.get();
Douglas Gregor77549082010-02-24 21:29:12 +00002726
2727 // C++ [expr.pseudo]p2:
2728 // The left-hand side of the dot operator shall be of scalar type. The
2729 // left-hand side of the arrow operator shall be of pointer to scalar type.
2730 // This scalar type is the object type.
2731 QualType ObjectType = BaseE->getType();
2732 if (OpKind == tok::arrow) {
2733 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
2734 ObjectType = Ptr->getPointeeType();
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002735 } else if (!ObjectType->isDependentType()) {
Douglas Gregor77549082010-02-24 21:29:12 +00002736 // The user wrote "p->" when she probably meant "p."; fix it.
2737 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002738 << ObjectType << true
2739 << CodeModificationHint::CreateReplacement(OpLoc, ".");
Douglas Gregor77549082010-02-24 21:29:12 +00002740 if (isSFINAEContext())
2741 return ExprError();
2742
2743 OpKind = tok::period;
2744 }
2745 }
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002746
2747 // Compute the object type that we should use for name lookup purposes. Only
2748 // record types and dependent types matter.
2749 void *ObjectTypePtrForLookup = 0;
2750 if (!SS.isSet()) {
2751 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>();
2752 if (!ObjectTypePtrForLookup && ObjectType->isDependentType())
2753 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr();
2754 }
Douglas Gregor77549082010-02-24 21:29:12 +00002755
Douglas Gregorb57fb492010-02-24 22:38:50 +00002756 // Convert the name of the type being destructed (following the ~) into a
2757 // type (with source-location information).
Douglas Gregor77549082010-02-24 21:29:12 +00002758 QualType DestructedType;
2759 TypeSourceInfo *DestructedTypeInfo = 0;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002760 PseudoDestructorTypeStorage Destructed;
Douglas Gregor77549082010-02-24 21:29:12 +00002761 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
2762 TypeTy *T = getTypeName(*SecondTypeName.Identifier,
2763 SecondTypeName.StartLocation,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002764 S, &SS, true, ObjectTypePtrForLookup);
2765 if (!T &&
2766 ((SS.isSet() && !computeDeclContext(SS, false)) ||
2767 (!SS.isSet() && ObjectType->isDependentType()))) {
2768 // The name of the type being destroyed is a dependent name, and we
2769 // couldn't find anything useful in scope. Just store the identifier and
2770 // it's location, and we'll perform (qualified) name lookup again at
2771 // template instantiation time.
2772 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
2773 SecondTypeName.StartLocation);
2774 } else if (!T) {
Douglas Gregor77549082010-02-24 21:29:12 +00002775 Diag(SecondTypeName.StartLocation,
2776 diag::err_pseudo_dtor_destructor_non_type)
2777 << SecondTypeName.Identifier << ObjectType;
2778 if (isSFINAEContext())
2779 return ExprError();
2780
2781 // Recover by assuming we had the right type all along.
2782 DestructedType = ObjectType;
Douglas Gregorb57fb492010-02-24 22:38:50 +00002783 } else
Douglas Gregor77549082010-02-24 21:29:12 +00002784 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00002785 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00002786 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00002787 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
Douglas Gregorb57fb492010-02-24 22:38:50 +00002788 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2789 TemplateId->getTemplateArgs(),
2790 TemplateId->NumArgs);
2791 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
2792 TemplateId->TemplateNameLoc,
2793 TemplateId->LAngleLoc,
2794 TemplateArgsPtr,
2795 TemplateId->RAngleLoc);
2796 if (T.isInvalid() || !T.get()) {
2797 // Recover by assuming we had the right type all along.
2798 DestructedType = ObjectType;
2799 } else
2800 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00002801 }
2802
Douglas Gregorb57fb492010-02-24 22:38:50 +00002803 // If we've performed some kind of recovery, (re-)build the type source
2804 // information.
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002805 if (!DestructedType.isNull()) {
2806 if (!DestructedTypeInfo)
2807 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
Douglas Gregorb57fb492010-02-24 22:38:50 +00002808 SecondTypeName.StartLocation);
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002809 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
2810 }
Douglas Gregorb57fb492010-02-24 22:38:50 +00002811
2812 // Convert the name of the scope type (the type prior to '::') into a type.
2813 TypeSourceInfo *ScopeTypeInfo = 0;
Douglas Gregor77549082010-02-24 21:29:12 +00002814 QualType ScopeType;
2815 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2816 FirstTypeName.Identifier) {
2817 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
2818 TypeTy *T = getTypeName(*FirstTypeName.Identifier,
2819 FirstTypeName.StartLocation,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002820 S, &SS, false, ObjectTypePtrForLookup);
Douglas Gregor77549082010-02-24 21:29:12 +00002821 if (!T) {
2822 Diag(FirstTypeName.StartLocation,
2823 diag::err_pseudo_dtor_destructor_non_type)
2824 << FirstTypeName.Identifier << ObjectType;
Douglas Gregor77549082010-02-24 21:29:12 +00002825
Douglas Gregorb57fb492010-02-24 22:38:50 +00002826 if (isSFINAEContext())
2827 return ExprError();
2828
2829 // Just drop this type. It's unnecessary anyway.
2830 ScopeType = QualType();
2831 } else
2832 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00002833 } else {
Douglas Gregorb57fb492010-02-24 22:38:50 +00002834 // Resolve the template-id to a type.
Douglas Gregor77549082010-02-24 21:29:12 +00002835 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
Douglas Gregorb57fb492010-02-24 22:38:50 +00002836 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2837 TemplateId->getTemplateArgs(),
2838 TemplateId->NumArgs);
2839 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
2840 TemplateId->TemplateNameLoc,
2841 TemplateId->LAngleLoc,
2842 TemplateArgsPtr,
2843 TemplateId->RAngleLoc);
2844 if (T.isInvalid() || !T.get()) {
2845 // Recover by dropping this type.
2846 ScopeType = QualType();
2847 } else
2848 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
Douglas Gregor77549082010-02-24 21:29:12 +00002849 }
2850 }
Douglas Gregorb4a418f2010-02-24 23:02:30 +00002851
2852 if (!ScopeType.isNull() && !ScopeTypeInfo)
2853 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
2854 FirstTypeName.StartLocation);
2855
2856
Douglas Gregorb57fb492010-02-24 22:38:50 +00002857 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS,
Douglas Gregorfce46ee2010-02-24 23:50:37 +00002858 ScopeTypeInfo, CCLoc, TildeLoc,
Douglas Gregora2e7dd22010-02-25 01:56:36 +00002859 Destructed, HasTrailingLParen);
Douglas Gregord4dca082010-02-24 18:44:31 +00002860}
2861
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002862CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp,
2863 CXXMethodDecl *Method) {
Douglas Gregor5fccd362010-03-03 23:55:11 +00002864 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, Method))
Eli Friedman772fffa2009-12-09 04:53:56 +00002865 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?");
2866
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002867 MemberExpr *ME =
2868 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method,
2869 SourceLocation(), Method->getType());
Eli Friedman772fffa2009-12-09 04:53:56 +00002870 QualType ResultType = Method->getResultType().getNonReferenceType();
Douglas Gregor7edfb692009-11-23 12:27:39 +00002871 MarkDeclarationReferenced(Exp->getLocStart(), Method);
2872 CXXMemberCallExpr *CE =
2873 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType,
2874 Exp->getLocEnd());
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002875 return CE;
2876}
2877
Anders Carlsson0aebc812009-09-09 21:33:21 +00002878Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc,
2879 QualType Ty,
2880 CastExpr::CastKind Kind,
2881 CXXMethodDecl *Method,
2882 ExprArg Arg) {
2883 Expr *From = Arg.takeAs<Expr>();
2884
2885 switch (Kind) {
2886 default: assert(0 && "Unhandled cast kind!");
2887 case CastExpr::CK_ConstructorConversion: {
Douglas Gregor39da0b82009-09-09 23:08:42 +00002888 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
2889
2890 if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method),
2891 MultiExprArg(*this, (void **)&From, 1),
2892 CastLoc, ConstructorArgs))
2893 return ExprError();
Anders Carlsson4fa26842009-10-18 21:20:14 +00002894
2895 OwningExprResult Result =
2896 BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method),
2897 move_arg(ConstructorArgs));
2898 if (Result.isInvalid())
2899 return ExprError();
2900
2901 return MaybeBindToTemporary(Result.takeAs<Expr>());
Anders Carlsson0aebc812009-09-09 21:33:21 +00002902 }
2903
2904 case CastExpr::CK_UserDefinedConversion: {
Anders Carlssonaac6e3a2009-09-15 07:42:44 +00002905 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
Eli Friedman772fffa2009-12-09 04:53:56 +00002906
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002907 // Create an implicit call expr that calls it.
2908 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method);
Anders Carlsson4fa26842009-10-18 21:20:14 +00002909 return MaybeBindToTemporary(CE);
Anders Carlsson0aebc812009-09-09 21:33:21 +00002910 }
Anders Carlsson0aebc812009-09-09 21:33:21 +00002911 }
2912}
2913
Anders Carlsson165a0a02009-05-17 18:41:29 +00002914Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
2915 Expr *FullExpr = Arg.takeAs<Expr>();
Anders Carlsson99ba36d2009-06-05 15:38:08 +00002916 if (FullExpr)
Anders Carlsson0ece4912009-12-15 20:51:39 +00002917 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr);
Anders Carlssonec773872009-08-25 23:46:41 +00002918
Anders Carlsson165a0a02009-05-17 18:41:29 +00002919 return Owned(FullExpr);
2920}