blob: f0e20496469259241872fb79d4c2042156d27d84 [file] [log] [blame]
Chris Lattner5b183d82006-11-10 05:03:26 +00001//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5b183d82006-11-10 05:03:26 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
John McCall83024632010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Douglas Gregorc3a6ade2010-08-12 20:07:10 +000015#include "clang/Sema/Initialization.h"
16#include "clang/Sema/Lookup.h"
17#include "clang/Sema/AnalysisBasedWarnings.h"
Chris Lattnercb6a3822006-11-10 06:20:45 +000018#include "clang/AST/ASTContext.h"
Douglas Gregord1702062010-04-29 00:18:15 +000019#include "clang/AST/CXXInheritance.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000020#include "clang/AST/DeclObjC.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000021#include "clang/AST/DeclTemplate.h"
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000022#include "clang/AST/EvaluatedExprVisitor.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000023#include "clang/AST/Expr.h"
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000024#include "clang/AST/ExprCXX.h"
Steve Naroff021ca182008-05-29 21:12:08 +000025#include "clang/AST/ExprObjC.h"
Douglas Gregor5597ab42010-05-07 23:12:07 +000026#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000027#include "clang/AST/TypeLoc.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000028#include "clang/Basic/PartialDiagnostic.h"
Steve Narofff2fb89e2007-03-13 20:29:44 +000029#include "clang/Basic/SourceManager.h"
Chris Lattner5b183d82006-11-10 05:03:26 +000030#include "clang/Basic/TargetInfo.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000031#include "clang/Lex/LiteralSupport.h"
32#include "clang/Lex/Preprocessor.h"
John McCall8b0666c2010-08-20 18:27:03 +000033#include "clang/Sema/DeclSpec.h"
34#include "clang/Sema/Designator.h"
35#include "clang/Sema/Scope.h"
John McCallaab3e412010-08-25 08:40:02 +000036#include "clang/Sema/ScopeInfo.h"
John McCall8b0666c2010-08-20 18:27:03 +000037#include "clang/Sema/ParsedTemplate.h"
John McCallde6836a2010-08-24 07:21:54 +000038#include "clang/Sema/Template.h"
Chris Lattner5b183d82006-11-10 05:03:26 +000039using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000040using namespace sema;
Chris Lattner5b183d82006-11-10 05:03:26 +000041
David Chisnall9f57c292009-08-17 16:35:33 +000042
Douglas Gregor171c45a2009-02-18 21:56:37 +000043/// \brief Determine whether the use of this declaration is valid, and
44/// emit any corresponding diagnostics.
45///
46/// This routine diagnoses various problems with referencing
47/// declarations that can occur when using a declaration. For example,
48/// it might warn if a deprecated or unavailable declaration is being
49/// used, or produce an error (and return true) if a C++0x deleted
50/// function is being used.
51///
Fariborz Jahanian7d6e11a2010-12-21 00:44:01 +000052/// If IgnoreDeprecated is set to true, this should not warn about deprecated
Chris Lattnerb7df3c62009-10-25 22:31:57 +000053/// decls.
54///
Douglas Gregor171c45a2009-02-18 21:56:37 +000055/// \returns true if there was an error (this declaration cannot be
56/// referenced), false otherwise.
Chris Lattnerb7df3c62009-10-25 22:31:57 +000057///
Fariborz Jahanian7d6e11a2010-12-21 00:44:01 +000058bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
Peter Collingbourneed12ffb2011-01-02 19:53:12 +000059 bool UnknownObjCClass) {
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +000060 if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) {
61 // If there were any diagnostics suppressed by template argument deduction,
62 // emit them now.
63 llvm::DenseMap<Decl *, llvm::SmallVector<PartialDiagnosticAt, 1> >::iterator
64 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
65 if (Pos != SuppressedDiagnostics.end()) {
66 llvm::SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second;
67 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I)
68 Diag(Suppressed[I].first, Suppressed[I].second);
69
70 // Clear out the list of suppressed diagnostics, so that we don't emit
71 // them again for this specialization. However, we don't remove this
72 // entry from the table, because we want to avoid ever emitting these
73 // diagnostics again.
74 Suppressed.clear();
75 }
76 }
77
Chris Lattner4bf74fd2009-02-15 22:43:40 +000078 // See if the decl is deprecated.
Benjamin Kramerbfac7dc2010-10-09 15:49:00 +000079 if (const DeprecatedAttr *DA = D->getAttr<DeprecatedAttr>())
Peter Collingbourneed12ffb2011-01-02 19:53:12 +000080 EmitDeprecationWarning(D, DA->getMessage(), Loc, UnknownObjCClass);
Chris Lattner4bf74fd2009-02-15 22:43:40 +000081
Chris Lattnera27dd592009-10-25 17:21:40 +000082 // See if the decl is unavailable
Fariborz Jahanianc74073c2010-10-06 23:12:32 +000083 if (const UnavailableAttr *UA = D->getAttr<UnavailableAttr>()) {
Fariborz Jahanian7d6e11a2010-12-21 00:44:01 +000084 if (UA->getMessage().empty()) {
Peter Collingbourneed12ffb2011-01-02 19:53:12 +000085 if (!UnknownObjCClass)
Fariborz Jahanian7d6e11a2010-12-21 00:44:01 +000086 Diag(Loc, diag::err_unavailable) << D->getDeclName();
87 else
88 Diag(Loc, diag::warn_unavailable_fwdclass_message)
89 << D->getDeclName();
90 }
91 else
Fariborz Jahanianc74073c2010-10-06 23:12:32 +000092 Diag(Loc, diag::err_unavailable_message)
Benjamin Kramerbfac7dc2010-10-09 15:49:00 +000093 << D->getDeclName() << UA->getMessage();
Chris Lattnera27dd592009-10-25 17:21:40 +000094 Diag(D->getLocation(), diag::note_unavailable_here) << 0;
95 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000096
Douglas Gregor171c45a2009-02-18 21:56:37 +000097 // See if this is a deleted function.
Douglas Gregorde681d42009-02-24 04:26:15 +000098 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Douglas Gregor171c45a2009-02-18 21:56:37 +000099 if (FD->isDeleted()) {
100 Diag(Loc, diag::err_deleted_function_use);
101 Diag(D->getLocation(), diag::note_unavailable_here) << true;
102 return true;
103 }
Douglas Gregorde681d42009-02-24 04:26:15 +0000104 }
Douglas Gregor171c45a2009-02-18 21:56:37 +0000105
Anders Carlsson73067a02010-10-22 23:37:08 +0000106 // Warn if this is used but marked unused.
107 if (D->hasAttr<UnusedAttr>())
108 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName();
109
Douglas Gregor171c45a2009-02-18 21:56:37 +0000110 return false;
Chris Lattner4bf74fd2009-02-15 22:43:40 +0000111}
112
Fariborz Jahanian027b8862009-05-13 18:09:35 +0000113/// DiagnoseSentinelCalls - This routine checks on method dispatch calls
Mike Stump11289f42009-09-09 15:08:12 +0000114/// (and other functions in future), which have been declared with sentinel
Fariborz Jahanian027b8862009-05-13 18:09:35 +0000115/// attribute. It warns if call does not have the sentinel argument.
116///
117void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
Mike Stump11289f42009-09-09 15:08:12 +0000118 Expr **Args, unsigned NumArgs) {
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000119 const SentinelAttr *attr = D->getAttr<SentinelAttr>();
Mike Stump11289f42009-09-09 15:08:12 +0000120 if (!attr)
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000121 return;
Douglas Gregorc298ffc2010-04-22 16:44:27 +0000122
123 // FIXME: In C++0x, if any of the arguments are parameter pack
124 // expansions, we can't check for the sentinel now.
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000125 int sentinelPos = attr->getSentinel();
126 int nullPos = attr->getNullPos();
Mike Stump11289f42009-09-09 15:08:12 +0000127
Mike Stump87c57ac2009-05-16 07:39:55 +0000128 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common
129 // base class. Then we won't be needing two versions of the same code.
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000130 unsigned int i = 0;
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000131 bool warnNotEnoughArgs = false;
132 int isMethod = 0;
133 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
134 // skip over named parameters.
135 ObjCMethodDecl::param_iterator P, E = MD->param_end();
136 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) {
137 if (nullPos)
138 --nullPos;
139 else
140 ++i;
141 }
142 warnNotEnoughArgs = (P != E || i >= NumArgs);
143 isMethod = 1;
Mike Stump12b8ce12009-08-04 21:02:39 +0000144 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000145 // skip over named parameters.
146 ObjCMethodDecl::param_iterator P, E = FD->param_end();
147 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) {
148 if (nullPos)
149 --nullPos;
150 else
151 ++i;
152 }
153 warnNotEnoughArgs = (P != E || i >= NumArgs);
Mike Stump12b8ce12009-08-04 21:02:39 +0000154 } else if (VarDecl *V = dyn_cast<VarDecl>(D)) {
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +0000155 // block or function pointer call.
156 QualType Ty = V->getType();
157 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
Mike Stump11289f42009-09-09 15:08:12 +0000158 const FunctionType *FT = Ty->isFunctionPointerType()
John McCall9dd450b2009-09-21 23:43:11 +0000159 ? Ty->getAs<PointerType>()->getPointeeType()->getAs<FunctionType>()
160 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +0000161 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) {
162 unsigned NumArgsInProto = Proto->getNumArgs();
163 unsigned k;
164 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) {
165 if (nullPos)
166 --nullPos;
167 else
168 ++i;
169 }
170 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs);
171 }
172 if (Ty->isBlockPointerType())
173 isMethod = 2;
Mike Stump12b8ce12009-08-04 21:02:39 +0000174 } else
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +0000175 return;
Mike Stump12b8ce12009-08-04 21:02:39 +0000176 } else
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000177 return;
178
179 if (warnNotEnoughArgs) {
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000180 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000181 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000182 return;
183 }
184 int sentinel = i;
185 while (sentinelPos > 0 && i < NumArgs-1) {
186 --sentinelPos;
187 ++i;
188 }
189 if (sentinelPos > 0) {
190 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000191 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000192 return;
193 }
194 while (i < NumArgs-1) {
195 ++i;
196 ++sentinel;
197 }
198 Expr *sentinelExpr = Args[sentinel];
John McCall7ddbcf42010-05-06 23:53:00 +0000199 if (!sentinelExpr) return;
200 if (sentinelExpr->isTypeDependent()) return;
201 if (sentinelExpr->isValueDependent()) return;
Anders Carlssone981a8c2010-11-05 15:21:33 +0000202
203 // nullptr_t is always treated as null.
204 if (sentinelExpr->getType()->isNullPtrType()) return;
205
Fariborz Jahanianc0b0ced2010-07-14 16:37:51 +0000206 if (sentinelExpr->getType()->isAnyPointerType() &&
John McCall7ddbcf42010-05-06 23:53:00 +0000207 sentinelExpr->IgnoreParenCasts()->isNullPointerConstant(Context,
208 Expr::NPC_ValueDependentIsNull))
209 return;
210
211 // Unfortunately, __null has type 'int'.
212 if (isa<GNUNullExpr>(sentinelExpr)) return;
213
214 Diag(Loc, diag::warn_missing_sentinel) << isMethod;
215 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian027b8862009-05-13 18:09:35 +0000216}
217
Douglas Gregor87f95b02009-02-26 21:00:50 +0000218SourceRange Sema::getExprRange(ExprTy *E) const {
219 Expr *Ex = (Expr *)E;
220 return Ex? Ex->getSourceRange() : SourceRange();
221}
222
Chris Lattner513165e2008-07-25 21:10:04 +0000223//===----------------------------------------------------------------------===//
224// Standard Promotions and Conversions
225//===----------------------------------------------------------------------===//
226
Chris Lattner513165e2008-07-25 21:10:04 +0000227/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
228void Sema::DefaultFunctionArrayConversion(Expr *&E) {
229 QualType Ty = E->getType();
230 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
231
Chris Lattner513165e2008-07-25 21:10:04 +0000232 if (Ty->isFunctionType())
Mike Stump11289f42009-09-09 15:08:12 +0000233 ImpCastExprToType(E, Context.getPointerType(Ty),
John McCalle3027922010-08-25 11:45:40 +0000234 CK_FunctionToPointerDecay);
Chris Lattner61f60a02008-07-25 21:33:13 +0000235 else if (Ty->isArrayType()) {
236 // In C90 mode, arrays only promote to pointers if the array expression is
237 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
238 // type 'array of type' is converted to an expression that has type 'pointer
239 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
240 // that has type 'array of type' ...". The relevant change is "an lvalue"
241 // (C90) to "an expression" (C99).
Argyrios Kyrtzidis9321c742008-09-11 04:25:59 +0000242 //
243 // C++ 4.2p1:
244 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
245 // T" can be converted to an rvalue of type "pointer to T".
246 //
John McCall086a4642010-11-24 05:12:34 +0000247 if (getLangOptions().C99 || getLangOptions().CPlusPlus || E->isLValue())
Anders Carlsson8fc489d2009-08-07 23:48:20 +0000248 ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
John McCalle3027922010-08-25 11:45:40 +0000249 CK_ArrayToPointerDecay);
Chris Lattner61f60a02008-07-25 21:33:13 +0000250 }
Chris Lattner513165e2008-07-25 21:10:04 +0000251}
252
John McCall27584242010-12-06 20:48:59 +0000253void Sema::DefaultLvalueConversion(Expr *&E) {
John McCallf3735e02010-12-01 04:43:34 +0000254 // C++ [conv.lval]p1:
255 // A glvalue of a non-function, non-array type T can be
256 // converted to a prvalue.
John McCall27584242010-12-06 20:48:59 +0000257 if (!E->isGLValue()) return;
John McCall34376a62010-12-04 03:47:34 +0000258
John McCall27584242010-12-06 20:48:59 +0000259 QualType T = E->getType();
260 assert(!T.isNull() && "r-value conversion on typeless expression?");
John McCall34376a62010-12-04 03:47:34 +0000261
John McCall27584242010-12-06 20:48:59 +0000262 // Create a load out of an ObjCProperty l-value, if necessary.
263 if (E->getObjectKind() == OK_ObjCProperty) {
264 ConvertPropertyForRValue(E);
265 if (!E->isGLValue())
John McCall34376a62010-12-04 03:47:34 +0000266 return;
Douglas Gregorb92a1562010-02-03 00:27:59 +0000267 }
John McCall27584242010-12-06 20:48:59 +0000268
269 // We don't want to throw lvalue-to-rvalue casts on top of
270 // expressions of certain types in C++.
271 if (getLangOptions().CPlusPlus &&
272 (E->getType() == Context.OverloadTy ||
273 T->isDependentType() ||
274 T->isRecordType()))
275 return;
276
277 // The C standard is actually really unclear on this point, and
278 // DR106 tells us what the result should be but not why. It's
279 // generally best to say that void types just doesn't undergo
280 // lvalue-to-rvalue at all. Note that expressions of unqualified
281 // 'void' type are never l-values, but qualified void can be.
282 if (T->isVoidType())
283 return;
284
285 // C++ [conv.lval]p1:
286 // [...] If T is a non-class type, the type of the prvalue is the
287 // cv-unqualified version of T. Otherwise, the type of the
288 // rvalue is T.
289 //
290 // C99 6.3.2.1p2:
291 // If the lvalue has qualified type, the value has the unqualified
292 // version of the type of the lvalue; otherwise, the value has the
293 // type of the lvalue.
294 if (T.hasQualifiers())
295 T = T.getUnqualifiedType();
296
297 E = ImplicitCastExpr::Create(Context, T, CK_LValueToRValue,
298 E, 0, VK_RValue);
299}
300
301void Sema::DefaultFunctionArrayLvalueConversion(Expr *&E) {
302 DefaultFunctionArrayConversion(E);
303 DefaultLvalueConversion(E);
Douglas Gregorb92a1562010-02-03 00:27:59 +0000304}
305
306
Chris Lattner513165e2008-07-25 21:10:04 +0000307/// UsualUnaryConversions - Performs various conversions that are common to most
Mike Stump11289f42009-09-09 15:08:12 +0000308/// operators (C99 6.3). The conversions of array and function types are
Chris Lattner513165e2008-07-25 21:10:04 +0000309/// sometimes surpressed. For example, the array->pointer conversion doesn't
310/// apply if the array is an argument to the sizeof or address (&) operators.
311/// In these instances, this routine should *not* be called.
John McCallf3735e02010-12-01 04:43:34 +0000312Expr *Sema::UsualUnaryConversions(Expr *&E) {
313 // First, convert to an r-value.
314 DefaultFunctionArrayLvalueConversion(E);
315
316 QualType Ty = E->getType();
Chris Lattner513165e2008-07-25 21:10:04 +0000317 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
John McCallf3735e02010-12-01 04:43:34 +0000318
319 // Try to perform integral promotions if the object has a theoretically
320 // promotable type.
321 if (Ty->isIntegralOrUnscopedEnumerationType()) {
322 // C99 6.3.1.1p2:
323 //
324 // The following may be used in an expression wherever an int or
325 // unsigned int may be used:
326 // - an object or expression with an integer type whose integer
327 // conversion rank is less than or equal to the rank of int
328 // and unsigned int.
329 // - A bit-field of type _Bool, int, signed int, or unsigned int.
330 //
331 // If an int can represent all values of the original type, the
332 // value is converted to an int; otherwise, it is converted to an
333 // unsigned int. These are called the integer promotions. All
334 // other types are unchanged by the integer promotions.
335
336 QualType PTy = Context.isPromotableBitField(E);
337 if (!PTy.isNull()) {
338 ImpCastExprToType(E, PTy, CK_IntegralCast);
339 return E;
340 }
341 if (Ty->isPromotableIntegerType()) {
342 QualType PT = Context.getPromotedIntegerType(Ty);
343 ImpCastExprToType(E, PT, CK_IntegralCast);
344 return E;
345 }
Eli Friedman629ffb92009-08-20 04:21:42 +0000346 }
347
John McCallf3735e02010-12-01 04:43:34 +0000348 return E;
Chris Lattner513165e2008-07-25 21:10:04 +0000349}
350
Chris Lattner2ce500f2008-07-25 22:25:12 +0000351/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
Mike Stump11289f42009-09-09 15:08:12 +0000352/// do not have a prototype. Arguments that have type float are promoted to
Chris Lattner2ce500f2008-07-25 22:25:12 +0000353/// double. All other argument types are converted by UsualUnaryConversions().
354void Sema::DefaultArgumentPromotion(Expr *&Expr) {
355 QualType Ty = Expr->getType();
356 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
Mike Stump11289f42009-09-09 15:08:12 +0000357
John McCall9bc26772010-12-06 18:36:11 +0000358 UsualUnaryConversions(Expr);
359
Chris Lattner2ce500f2008-07-25 22:25:12 +0000360 // If this is a 'float' (CVR qualified or typedef) promote to double.
Chris Lattnerbb53efb2010-05-16 04:01:30 +0000361 if (Ty->isSpecificBuiltinType(BuiltinType::Float))
John McCall9bc26772010-12-06 18:36:11 +0000362 return ImpCastExprToType(Expr, Context.DoubleTy, CK_FloatingCast);
Chris Lattner2ce500f2008-07-25 22:25:12 +0000363}
364
Chris Lattnera8a7d0f2009-04-12 08:11:20 +0000365/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
366/// will warn if the resulting type is not a POD type, and rejects ObjC
367/// interfaces passed by value. This returns true if the argument type is
368/// completely illegal.
Chris Lattnerbb53efb2010-05-16 04:01:30 +0000369bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT,
370 FunctionDecl *FDecl) {
Anders Carlssona7d069d2009-01-16 16:48:51 +0000371 DefaultArgumentPromotion(Expr);
Mike Stump11289f42009-09-09 15:08:12 +0000372
Chris Lattnerbb53efb2010-05-16 04:01:30 +0000373 // __builtin_va_start takes the second argument as a "varargs" argument, but
374 // it doesn't actually do anything with it. It doesn't need to be non-pod
375 // etc.
376 if (FDecl && FDecl->getBuiltinID() == Builtin::BI__builtin_va_start)
377 return false;
378
John McCall8b07ec22010-05-15 11:32:37 +0000379 if (Expr->getType()->isObjCObjectType() &&
Douglas Gregorda8cdbc2009-12-22 01:01:55 +0000380 DiagRuntimeBehavior(Expr->getLocStart(),
381 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
382 << Expr->getType() << CT))
383 return true;
Douglas Gregor7ca84af2009-12-12 07:25:49 +0000384
Douglas Gregorda8cdbc2009-12-22 01:01:55 +0000385 if (!Expr->getType()->isPODType() &&
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +0000386 DiagRuntimeBehavior(Expr->getLocStart(),
Douglas Gregorda8cdbc2009-12-22 01:01:55 +0000387 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
388 << Expr->getType() << CT))
389 return true;
Chris Lattnera8a7d0f2009-04-12 08:11:20 +0000390
391 return false;
Anders Carlssona7d069d2009-01-16 16:48:51 +0000392}
393
Chris Lattner513165e2008-07-25 21:10:04 +0000394/// UsualArithmeticConversions - Performs various conversions that are common to
395/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
Mike Stump11289f42009-09-09 15:08:12 +0000396/// routine returns the first non-arithmetic type found. The client is
Chris Lattner513165e2008-07-25 21:10:04 +0000397/// responsible for emitting appropriate error diagnostics.
398/// FIXME: verify the conversion rules for "complex int" are consistent with
399/// GCC.
400QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
401 bool isCompAssign) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +0000402 if (!isCompAssign)
Chris Lattner513165e2008-07-25 21:10:04 +0000403 UsualUnaryConversions(lhsExpr);
Eli Friedman8b7b1b12009-03-28 01:22:36 +0000404
405 UsualUnaryConversions(rhsExpr);
Douglas Gregora11693b2008-11-12 17:17:38 +0000406
Mike Stump11289f42009-09-09 15:08:12 +0000407 // For conversion purposes, we ignore any qualifiers.
Chris Lattner513165e2008-07-25 21:10:04 +0000408 // For example, "const float" and "float" are equivalent.
Chris Lattner574dee62008-07-26 22:17:49 +0000409 QualType lhs =
410 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
Mike Stump11289f42009-09-09 15:08:12 +0000411 QualType rhs =
Chris Lattner574dee62008-07-26 22:17:49 +0000412 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
Douglas Gregora11693b2008-11-12 17:17:38 +0000413
414 // If both types are identical, no conversion is needed.
415 if (lhs == rhs)
416 return lhs;
417
418 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
419 // The caller can deal with this (e.g. pointer + int).
420 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
421 return lhs;
422
John McCalld005ac92010-11-13 08:17:45 +0000423 // Apply unary and bitfield promotions to the LHS's type.
424 QualType lhs_unpromoted = lhs;
425 if (lhs->isPromotableIntegerType())
426 lhs = Context.getPromotedIntegerType(lhs);
Eli Friedman629ffb92009-08-20 04:21:42 +0000427 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(lhsExpr);
Douglas Gregord2c2d172009-05-02 00:36:19 +0000428 if (!LHSBitfieldPromoteTy.isNull())
429 lhs = LHSBitfieldPromoteTy;
John McCalld005ac92010-11-13 08:17:45 +0000430 if (lhs != lhs_unpromoted && !isCompAssign)
431 ImpCastExprToType(lhsExpr, lhs, CK_IntegralCast);
Douglas Gregord2c2d172009-05-02 00:36:19 +0000432
John McCalld005ac92010-11-13 08:17:45 +0000433 // If both types are identical, no conversion is needed.
434 if (lhs == rhs)
435 return lhs;
436
437 // At this point, we have two different arithmetic types.
438
439 // Handle complex types first (C99 6.3.1.8p1).
440 bool LHSComplexFloat = lhs->isComplexType();
441 bool RHSComplexFloat = rhs->isComplexType();
442 if (LHSComplexFloat || RHSComplexFloat) {
443 // if we have an integer operand, the result is the complex type.
444
John McCallc5e62b42010-11-13 09:02:35 +0000445 if (!RHSComplexFloat && !rhs->isRealFloatingType()) {
446 if (rhs->isIntegerType()) {
447 QualType fp = cast<ComplexType>(lhs)->getElementType();
448 ImpCastExprToType(rhsExpr, fp, CK_IntegralToFloating);
449 ImpCastExprToType(rhsExpr, lhs, CK_FloatingRealToComplex);
450 } else {
451 assert(rhs->isComplexIntegerType());
John McCalld7646252010-11-14 08:17:51 +0000452 ImpCastExprToType(rhsExpr, lhs, CK_IntegralComplexToFloatingComplex);
John McCallc5e62b42010-11-13 09:02:35 +0000453 }
John McCalld005ac92010-11-13 08:17:45 +0000454 return lhs;
455 }
456
John McCallc5e62b42010-11-13 09:02:35 +0000457 if (!LHSComplexFloat && !lhs->isRealFloatingType()) {
458 if (!isCompAssign) {
459 // int -> float -> _Complex float
460 if (lhs->isIntegerType()) {
461 QualType fp = cast<ComplexType>(rhs)->getElementType();
462 ImpCastExprToType(lhsExpr, fp, CK_IntegralToFloating);
463 ImpCastExprToType(lhsExpr, rhs, CK_FloatingRealToComplex);
464 } else {
465 assert(lhs->isComplexIntegerType());
John McCalld7646252010-11-14 08:17:51 +0000466 ImpCastExprToType(lhsExpr, rhs, CK_IntegralComplexToFloatingComplex);
John McCallc5e62b42010-11-13 09:02:35 +0000467 }
468 }
John McCalld005ac92010-11-13 08:17:45 +0000469 return rhs;
470 }
471
472 // This handles complex/complex, complex/float, or float/complex.
473 // When both operands are complex, the shorter operand is converted to the
474 // type of the longer, and that is the type of the result. This corresponds
475 // to what is done when combining two real floating-point operands.
476 // The fun begins when size promotion occur across type domains.
477 // From H&S 6.3.4: When one operand is complex and the other is a real
478 // floating-point type, the less precise type is converted, within it's
479 // real or complex domain, to the precision of the other type. For example,
480 // when combining a "long double" with a "double _Complex", the
481 // "double _Complex" is promoted to "long double _Complex".
482 int order = Context.getFloatingTypeOrder(lhs, rhs);
483
484 // If both are complex, just cast to the more precise type.
485 if (LHSComplexFloat && RHSComplexFloat) {
486 if (order > 0) {
487 // _Complex float -> _Complex double
John McCallc5e62b42010-11-13 09:02:35 +0000488 ImpCastExprToType(rhsExpr, lhs, CK_FloatingComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000489 return lhs;
490
491 } else if (order < 0) {
492 // _Complex float -> _Complex double
493 if (!isCompAssign)
John McCallc5e62b42010-11-13 09:02:35 +0000494 ImpCastExprToType(lhsExpr, rhs, CK_FloatingComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000495 return rhs;
496 }
497 return lhs;
498 }
499
500 // If just the LHS is complex, the RHS needs to be converted,
501 // and the LHS might need to be promoted.
502 if (LHSComplexFloat) {
503 if (order > 0) { // LHS is wider
504 // float -> _Complex double
John McCallc5e62b42010-11-13 09:02:35 +0000505 QualType fp = cast<ComplexType>(lhs)->getElementType();
506 ImpCastExprToType(rhsExpr, fp, CK_FloatingCast);
507 ImpCastExprToType(rhsExpr, lhs, CK_FloatingRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000508 return lhs;
509 }
510
511 // RHS is at least as wide. Find its corresponding complex type.
512 QualType result = (order == 0 ? lhs : Context.getComplexType(rhs));
513
514 // double -> _Complex double
John McCallc5e62b42010-11-13 09:02:35 +0000515 ImpCastExprToType(rhsExpr, result, CK_FloatingRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000516
517 // _Complex float -> _Complex double
518 if (!isCompAssign && order < 0)
John McCallc5e62b42010-11-13 09:02:35 +0000519 ImpCastExprToType(lhsExpr, result, CK_FloatingComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000520
521 return result;
522 }
523
524 // Just the RHS is complex, so the LHS needs to be converted
525 // and the RHS might need to be promoted.
526 assert(RHSComplexFloat);
527
528 if (order < 0) { // RHS is wider
529 // float -> _Complex double
John McCallc5e62b42010-11-13 09:02:35 +0000530 if (!isCompAssign) {
531 ImpCastExprToType(lhsExpr, rhs, CK_FloatingCast);
532 ImpCastExprToType(lhsExpr, rhs, CK_FloatingRealToComplex);
533 }
John McCalld005ac92010-11-13 08:17:45 +0000534 return rhs;
535 }
536
537 // LHS is at least as wide. Find its corresponding complex type.
538 QualType result = (order == 0 ? rhs : Context.getComplexType(lhs));
539
540 // double -> _Complex double
541 if (!isCompAssign)
John McCallc5e62b42010-11-13 09:02:35 +0000542 ImpCastExprToType(lhsExpr, result, CK_FloatingRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000543
544 // _Complex float -> _Complex double
545 if (order > 0)
John McCallc5e62b42010-11-13 09:02:35 +0000546 ImpCastExprToType(rhsExpr, result, CK_FloatingComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000547
548 return result;
549 }
550
551 // Now handle "real" floating types (i.e. float, double, long double).
552 bool LHSFloat = lhs->isRealFloatingType();
553 bool RHSFloat = rhs->isRealFloatingType();
554 if (LHSFloat || RHSFloat) {
555 // If we have two real floating types, convert the smaller operand
556 // to the bigger result.
557 if (LHSFloat && RHSFloat) {
558 int order = Context.getFloatingTypeOrder(lhs, rhs);
559 if (order > 0) {
560 ImpCastExprToType(rhsExpr, lhs, CK_FloatingCast);
561 return lhs;
562 }
563
564 assert(order < 0 && "illegal float comparison");
565 if (!isCompAssign)
566 ImpCastExprToType(lhsExpr, rhs, CK_FloatingCast);
567 return rhs;
568 }
569
570 // If we have an integer operand, the result is the real floating type.
571 if (LHSFloat) {
572 if (rhs->isIntegerType()) {
573 // Convert rhs to the lhs floating point type.
574 ImpCastExprToType(rhsExpr, lhs, CK_IntegralToFloating);
575 return lhs;
576 }
577
578 // Convert both sides to the appropriate complex float.
579 assert(rhs->isComplexIntegerType());
580 QualType result = Context.getComplexType(lhs);
581
582 // _Complex int -> _Complex float
John McCalld7646252010-11-14 08:17:51 +0000583 ImpCastExprToType(rhsExpr, result, CK_IntegralComplexToFloatingComplex);
John McCalld005ac92010-11-13 08:17:45 +0000584
585 // float -> _Complex float
586 if (!isCompAssign)
John McCallc5e62b42010-11-13 09:02:35 +0000587 ImpCastExprToType(lhsExpr, result, CK_FloatingRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000588
589 return result;
590 }
591
592 assert(RHSFloat);
593 if (lhs->isIntegerType()) {
594 // Convert lhs to the rhs floating point type.
595 if (!isCompAssign)
596 ImpCastExprToType(lhsExpr, rhs, CK_IntegralToFloating);
597 return rhs;
598 }
599
600 // Convert both sides to the appropriate complex float.
601 assert(lhs->isComplexIntegerType());
602 QualType result = Context.getComplexType(rhs);
603
604 // _Complex int -> _Complex float
605 if (!isCompAssign)
John McCalld7646252010-11-14 08:17:51 +0000606 ImpCastExprToType(lhsExpr, result, CK_IntegralComplexToFloatingComplex);
John McCalld005ac92010-11-13 08:17:45 +0000607
608 // float -> _Complex float
John McCallc5e62b42010-11-13 09:02:35 +0000609 ImpCastExprToType(rhsExpr, result, CK_FloatingRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000610
611 return result;
612 }
613
614 // Handle GCC complex int extension.
615 // FIXME: if the operands are (int, _Complex long), we currently
616 // don't promote the complex. Also, signedness?
617 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
618 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
619 if (lhsComplexInt && rhsComplexInt) {
620 int order = Context.getIntegerTypeOrder(lhsComplexInt->getElementType(),
621 rhsComplexInt->getElementType());
622 assert(order && "inequal types with equal element ordering");
623 if (order > 0) {
624 // _Complex int -> _Complex long
John McCallc5e62b42010-11-13 09:02:35 +0000625 ImpCastExprToType(rhsExpr, lhs, CK_IntegralComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000626 return lhs;
627 }
628
629 if (!isCompAssign)
John McCallc5e62b42010-11-13 09:02:35 +0000630 ImpCastExprToType(lhsExpr, rhs, CK_IntegralComplexCast);
John McCalld005ac92010-11-13 08:17:45 +0000631 return rhs;
632 } else if (lhsComplexInt) {
633 // int -> _Complex int
John McCallc5e62b42010-11-13 09:02:35 +0000634 ImpCastExprToType(rhsExpr, lhs, CK_IntegralRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000635 return lhs;
636 } else if (rhsComplexInt) {
637 // int -> _Complex int
638 if (!isCompAssign)
John McCallc5e62b42010-11-13 09:02:35 +0000639 ImpCastExprToType(lhsExpr, rhs, CK_IntegralRealToComplex);
John McCalld005ac92010-11-13 08:17:45 +0000640 return rhs;
641 }
642
643 // Finally, we have two differing integer types.
644 // The rules for this case are in C99 6.3.1.8
645 int compare = Context.getIntegerTypeOrder(lhs, rhs);
646 bool lhsSigned = lhs->hasSignedIntegerRepresentation(),
647 rhsSigned = rhs->hasSignedIntegerRepresentation();
648 if (lhsSigned == rhsSigned) {
649 // Same signedness; use the higher-ranked type
650 if (compare >= 0) {
651 ImpCastExprToType(rhsExpr, lhs, CK_IntegralCast);
652 return lhs;
653 } else if (!isCompAssign)
654 ImpCastExprToType(lhsExpr, rhs, CK_IntegralCast);
655 return rhs;
656 } else if (compare != (lhsSigned ? 1 : -1)) {
657 // The unsigned type has greater than or equal rank to the
658 // signed type, so use the unsigned type
659 if (rhsSigned) {
660 ImpCastExprToType(rhsExpr, lhs, CK_IntegralCast);
661 return lhs;
662 } else if (!isCompAssign)
663 ImpCastExprToType(lhsExpr, rhs, CK_IntegralCast);
664 return rhs;
665 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) {
666 // The two types are different widths; if we are here, that
667 // means the signed type is larger than the unsigned type, so
668 // use the signed type.
669 if (lhsSigned) {
670 ImpCastExprToType(rhsExpr, lhs, CK_IntegralCast);
671 return lhs;
672 } else if (!isCompAssign)
673 ImpCastExprToType(lhsExpr, rhs, CK_IntegralCast);
674 return rhs;
675 } else {
676 // The signed type is higher-ranked than the unsigned type,
677 // but isn't actually any bigger (like unsigned int and long
678 // on most 32-bit systems). Use the unsigned type corresponding
679 // to the signed type.
680 QualType result =
681 Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
682 ImpCastExprToType(rhsExpr, result, CK_IntegralCast);
683 if (!isCompAssign)
684 ImpCastExprToType(lhsExpr, result, CK_IntegralCast);
685 return result;
686 }
Douglas Gregora11693b2008-11-12 17:17:38 +0000687}
688
Chris Lattner513165e2008-07-25 21:10:04 +0000689//===----------------------------------------------------------------------===//
690// Semantic Analysis for various Expression Types
691//===----------------------------------------------------------------------===//
692
693
Steve Naroff83895f72007-09-16 03:34:24 +0000694/// ActOnStringLiteral - The specified tokens were lexed as pasted string
Chris Lattner5b183d82006-11-10 05:03:26 +0000695/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
696/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
697/// multiple tokens. However, the common case is that StringToks points to one
698/// string.
Sebastian Redlffbcf962009-01-18 18:53:16 +0000699///
John McCalldadc5752010-08-24 06:29:42 +0000700ExprResult
Alexis Hunt3b791862010-08-30 17:47:05 +0000701Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
Chris Lattner5b183d82006-11-10 05:03:26 +0000702 assert(NumStringToks && "Must have at least one string!");
703
Chris Lattner8a24e582009-01-16 18:51:42 +0000704 StringLiteralParser Literal(StringToks, NumStringToks, PP);
Steve Naroff4f88b312007-03-13 22:37:02 +0000705 if (Literal.hadError)
Sebastian Redlffbcf962009-01-18 18:53:16 +0000706 return ExprError();
Chris Lattner5b183d82006-11-10 05:03:26 +0000707
Chris Lattner23b7eb62007-06-15 23:05:46 +0000708 llvm::SmallVector<SourceLocation, 4> StringTokLocs;
Chris Lattner5b183d82006-11-10 05:03:26 +0000709 for (unsigned i = 0; i != NumStringToks; ++i)
710 StringTokLocs.push_back(StringToks[i].getLocation());
Chris Lattner36fc8792008-02-11 00:02:17 +0000711
Chris Lattner36fc8792008-02-11 00:02:17 +0000712 QualType StrTy = Context.CharTy;
Argyrios Kyrtzidiscbad7252008-08-09 17:20:01 +0000713 if (Literal.AnyWide) StrTy = Context.getWCharType();
Chris Lattner36fc8792008-02-11 00:02:17 +0000714 if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
Douglas Gregoraa1e21d2008-09-12 00:47:35 +0000715
716 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
Chris Lattnera8687ae2010-06-15 18:05:34 +0000717 if (getLangOptions().CPlusPlus || getLangOptions().ConstStrings)
Douglas Gregoraa1e21d2008-09-12 00:47:35 +0000718 StrTy.addConst();
Sebastian Redlffbcf962009-01-18 18:53:16 +0000719
Chris Lattner36fc8792008-02-11 00:02:17 +0000720 // Get an array type for the string, according to C99 6.4.5. This includes
721 // the nul terminator character as well as the string length for pascal
722 // strings.
723 StrTy = Context.getConstantArrayType(StrTy,
Chris Lattnerd42c29f2009-02-26 23:01:51 +0000724 llvm::APInt(32, Literal.GetNumStringChars()+1),
Chris Lattner36fc8792008-02-11 00:02:17 +0000725 ArrayType::Normal, 0);
Mike Stump11289f42009-09-09 15:08:12 +0000726
Chris Lattner5b183d82006-11-10 05:03:26 +0000727 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
Alexis Hunt3b791862010-08-30 17:47:05 +0000728 return Owned(StringLiteral::Create(Context, Literal.GetString(),
729 Literal.GetStringLength(),
730 Literal.AnyWide, StrTy,
731 &StringTokLocs[0],
732 StringTokLocs.size()));
Chris Lattner5b183d82006-11-10 05:03:26 +0000733}
734
Chris Lattner2a9d9892008-10-20 05:16:36 +0000735/// ShouldSnapshotBlockValueReference - Return true if a reference inside of
736/// CurBlock to VD should cause it to be snapshotted (as we do for auto
737/// variables defined outside the block) or false if this is not needed (e.g.
738/// for values inside the block or for globals).
739///
Douglas Gregor4f13beb2010-03-01 20:44:28 +0000740/// This also keeps the 'hasBlockDeclRefExprs' in the BlockScopeInfo records
Chris Lattner497d7b02009-04-21 22:26:47 +0000741/// up-to-date.
742///
Douglas Gregor9a28e842010-03-01 23:15:13 +0000743static bool ShouldSnapshotBlockValueReference(Sema &S, BlockScopeInfo *CurBlock,
Chris Lattner2a9d9892008-10-20 05:16:36 +0000744 ValueDecl *VD) {
745 // If the value is defined inside the block, we couldn't snapshot it even if
746 // we wanted to.
747 if (CurBlock->TheDecl == VD->getDeclContext())
748 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000749
Chris Lattner2a9d9892008-10-20 05:16:36 +0000750 // If this is an enum constant or function, it is constant, don't snapshot.
751 if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD))
752 return false;
753
754 // If this is a reference to an extern, static, or global variable, no need to
755 // snapshot it.
756 // FIXME: What about 'const' variables in C++?
757 if (const VarDecl *Var = dyn_cast<VarDecl>(VD))
Chris Lattner497d7b02009-04-21 22:26:47 +0000758 if (!Var->hasLocalStorage())
759 return false;
Mike Stump11289f42009-09-09 15:08:12 +0000760
Chris Lattner497d7b02009-04-21 22:26:47 +0000761 // Blocks that have these can't be constant.
762 CurBlock->hasBlockDeclRefExprs = true;
763
764 // If we have nested blocks, the decl may be declared in an outer block (in
765 // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may
766 // be defined outside all of the current blocks (in which case the blocks do
767 // all get the bit). Walk the nesting chain.
Douglas Gregor9a28e842010-03-01 23:15:13 +0000768 for (unsigned I = S.FunctionScopes.size() - 1; I; --I) {
769 BlockScopeInfo *NextBlock = dyn_cast<BlockScopeInfo>(S.FunctionScopes[I]);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +0000770
Douglas Gregor9a28e842010-03-01 23:15:13 +0000771 if (!NextBlock)
772 continue;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +0000773
Chris Lattner497d7b02009-04-21 22:26:47 +0000774 // If we found the defining block for the variable, don't mark the block as
775 // having a reference outside it.
776 if (NextBlock->TheDecl == VD->getDeclContext())
777 break;
Mike Stump11289f42009-09-09 15:08:12 +0000778
Chris Lattner497d7b02009-04-21 22:26:47 +0000779 // Otherwise, the DeclRef from the inner block causes the outer one to need
780 // a snapshot as well.
781 NextBlock->hasBlockDeclRefExprs = true;
782 }
Mike Stump11289f42009-09-09 15:08:12 +0000783
Chris Lattner2a9d9892008-10-20 05:16:36 +0000784 return true;
Mike Stump11289f42009-09-09 15:08:12 +0000785}
786
Chris Lattner2a9d9892008-10-20 05:16:36 +0000787
John McCalldadc5752010-08-24 06:29:42 +0000788ExprResult
John McCall7decc9e2010-11-18 06:31:45 +0000789Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
790 SourceLocation Loc, const CXXScopeSpec *SS) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000791 DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
John McCall7decc9e2010-11-18 06:31:45 +0000792 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000793}
794
795/// BuildDeclRefExpr - Build a DeclRefExpr.
John McCalldadc5752010-08-24 06:29:42 +0000796ExprResult
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000797Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty,
John McCall7decc9e2010-11-18 06:31:45 +0000798 ExprValueKind VK,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000799 const DeclarationNameInfo &NameInfo,
800 const CXXScopeSpec *SS) {
Anders Carlsson364035d12009-06-26 19:16:07 +0000801 if (Context.getCanonicalType(Ty) == Context.UndeducedAutoTy) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000802 Diag(NameInfo.getLoc(),
Mike Stump11289f42009-09-09 15:08:12 +0000803 diag::err_auto_variable_cannot_appear_in_own_initializer)
Anders Carlsson364035d12009-06-26 19:16:07 +0000804 << D->getDeclName();
805 return ExprError();
806 }
Mike Stump11289f42009-09-09 15:08:12 +0000807
Anders Carlsson946b86d2009-06-24 00:10:43 +0000808 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Douglas Gregor15243332010-04-27 21:10:04 +0000809 if (isa<NonTypeTemplateParmDecl>(VD)) {
810 // Non-type template parameters can be referenced anywhere they are
811 // visible.
Douglas Gregora8a089b2010-07-13 18:40:04 +0000812 Ty = Ty.getNonLValueExprType(Context);
Douglas Gregor15243332010-04-27 21:10:04 +0000813 } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
Anders Carlsson946b86d2009-06-24 00:10:43 +0000814 if (const FunctionDecl *FD = MD->getParent()->isLocalClass()) {
815 if (VD->hasLocalStorage() && VD->getDeclContext() != CurContext) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000816 Diag(NameInfo.getLoc(),
817 diag::err_reference_to_local_var_in_enclosing_function)
Anders Carlsson946b86d2009-06-24 00:10:43 +0000818 << D->getIdentifier() << FD->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +0000819 Diag(D->getLocation(), diag::note_local_variable_declared_here)
Anders Carlsson946b86d2009-06-24 00:10:43 +0000820 << D->getIdentifier();
821 return ExprError();
822 }
823 }
John McCall4bc41ae2010-11-18 19:01:18 +0000824
825 // This ridiculousness brought to you by 'extern void x;' and the
826 // GNU compiler collection.
827 } else if (!getLangOptions().CPlusPlus && !Ty.hasQualifiers() &&
828 Ty->isVoidType()) {
829 VK = VK_RValue;
Anders Carlsson946b86d2009-06-24 00:10:43 +0000830 }
831 }
Mike Stump11289f42009-09-09 15:08:12 +0000832
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000833 MarkDeclarationReferenced(NameInfo.getLoc(), D);
Mike Stump11289f42009-09-09 15:08:12 +0000834
John McCall086a4642010-11-24 05:12:34 +0000835 Expr *E = DeclRefExpr::Create(Context,
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +0000836 SS? (NestedNameSpecifier *)SS->getScopeRep() : 0,
John McCall086a4642010-11-24 05:12:34 +0000837 SS? SS->getRange() : SourceRange(),
838 D, NameInfo, Ty, VK);
839
840 // Just in case we're building an illegal pointer-to-member.
841 if (isa<FieldDecl>(D) && cast<FieldDecl>(D)->getBitWidth())
842 E->setObjectKind(OK_BitField);
843
844 return Owned(E);
Douglas Gregorc7acfdf2009-01-06 05:10:23 +0000845}
846
John McCallfeb624a2010-11-23 20:48:44 +0000847static ExprResult
848BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
849 const CXXScopeSpec &SS, FieldDecl *Field,
850 DeclAccessPair FoundDecl,
851 const DeclarationNameInfo &MemberNameInfo);
852
John McCalldadc5752010-08-24 06:29:42 +0000853ExprResult
Douglas Gregord5846a12009-04-15 06:41:24 +0000854Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
Francois Pichet783dd6e2010-11-21 06:08:52 +0000855 IndirectFieldDecl *IndirectField,
Douglas Gregord5846a12009-04-15 06:41:24 +0000856 Expr *BaseObjectExpr,
857 SourceLocation OpLoc) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000858 // Build the expression that refers to the base object, from
859 // which we will build a sequence of member references to each
860 // of the anonymous union objects and, eventually, the field we
861 // found via name lookup.
862 bool BaseObjectIsPointer = false;
John McCall8ccfcb52009-09-24 19:53:00 +0000863 Qualifiers BaseQuals;
Francois Pichet783dd6e2010-11-21 06:08:52 +0000864 VarDecl *BaseObject = IndirectField->getVarDecl();
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000865 if (BaseObject) {
866 // BaseObject is an anonymous struct/union variable (and is,
867 // therefore, not part of another non-anonymous record).
Douglas Gregorc9c02ed2009-06-19 23:52:42 +0000868 MarkDeclarationReferenced(Loc, BaseObject);
John McCall7decc9e2010-11-18 06:31:45 +0000869 BaseObjectExpr =
870 new (Context) DeclRefExpr(BaseObject, BaseObject->getType(),
871 VK_LValue, Loc);
John McCall8ccfcb52009-09-24 19:53:00 +0000872 BaseQuals
873 = Context.getCanonicalType(BaseObject->getType()).getQualifiers();
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000874 } else if (BaseObjectExpr) {
875 // The caller provided the base object expression. Determine
876 // whether its a pointer and whether it adds any qualifiers to the
877 // anonymous struct/union fields we're looking into.
878 QualType ObjectType = BaseObjectExpr->getType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000879 if (const PointerType *ObjectPtr = ObjectType->getAs<PointerType>()) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000880 BaseObjectIsPointer = true;
881 ObjectType = ObjectPtr->getPointeeType();
882 }
John McCall8ccfcb52009-09-24 19:53:00 +0000883 BaseQuals
884 = Context.getCanonicalType(ObjectType).getQualifiers();
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000885 } else {
886 // We've found a member of an anonymous struct/union that is
887 // inside a non-anonymous struct/union, so in a well-formed
888 // program our base object expression is "this".
John McCall87fe5d52010-05-20 01:18:31 +0000889 DeclContext *DC = getFunctionLevelDeclContext();
890 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000891 if (!MD->isStatic()) {
Mike Stump11289f42009-09-09 15:08:12 +0000892 QualType AnonFieldType
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000893 = Context.getTagDeclType(
Francois Pichet783dd6e2010-11-21 06:08:52 +0000894 cast<RecordDecl>(
895 (*IndirectField->chain_begin())->getDeclContext()));
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000896 QualType ThisType = Context.getTagDeclType(MD->getParent());
Mike Stump11289f42009-09-09 15:08:12 +0000897 if ((Context.getCanonicalType(AnonFieldType)
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000898 == Context.getCanonicalType(ThisType)) ||
899 IsDerivedFrom(ThisType, AnonFieldType)) {
900 // Our base object expression is "this".
Douglas Gregor4b654412009-12-24 20:23:34 +0000901 BaseObjectExpr = new (Context) CXXThisExpr(Loc,
Douglas Gregorb15af892010-01-07 23:12:05 +0000902 MD->getThisType(Context),
903 /*isImplicit=*/true);
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000904 BaseObjectIsPointer = true;
905 }
906 } else {
Sebastian Redlffbcf962009-01-18 18:53:16 +0000907 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
Francois Pichet783dd6e2010-11-21 06:08:52 +0000908 << IndirectField->getDeclName());
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000909 }
John McCall8ccfcb52009-09-24 19:53:00 +0000910 BaseQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000911 }
912
Mike Stump11289f42009-09-09 15:08:12 +0000913 if (!BaseObjectExpr)
Sebastian Redlffbcf962009-01-18 18:53:16 +0000914 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
Francois Pichet783dd6e2010-11-21 06:08:52 +0000915 << IndirectField->getDeclName());
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000916 }
917
918 // Build the implicit member references to the field of the
919 // anonymous struct/union.
920 Expr *Result = BaseObjectExpr;
John McCallfeb624a2010-11-23 20:48:44 +0000921
Francois Pichet783dd6e2010-11-21 06:08:52 +0000922 IndirectFieldDecl::chain_iterator FI = IndirectField->chain_begin(),
923 FEnd = IndirectField->chain_end();
John McCallfeb624a2010-11-23 20:48:44 +0000924
Francois Pichet783dd6e2010-11-21 06:08:52 +0000925 // Skip the first VarDecl if present.
926 if (BaseObject)
927 FI++;
928 for (; FI != FEnd; FI++) {
929 FieldDecl *Field = cast<FieldDecl>(*FI);
John McCall8ccfcb52009-09-24 19:53:00 +0000930
John McCallfeb624a2010-11-23 20:48:44 +0000931 // FIXME: the first access can be qualified
932 CXXScopeSpec SS;
John McCall8ccfcb52009-09-24 19:53:00 +0000933
John McCallfeb624a2010-11-23 20:48:44 +0000934 // FIXME: these are somewhat meaningless
935 DeclarationNameInfo MemberNameInfo(Field->getDeclName(), Loc);
936 DeclAccessPair FoundDecl = DeclAccessPair::make(Field, Field->getAccess());
John McCall8ccfcb52009-09-24 19:53:00 +0000937
John McCallfeb624a2010-11-23 20:48:44 +0000938 Result = BuildFieldReferenceExpr(*this, Result, BaseObjectIsPointer,
939 SS, Field, FoundDecl, MemberNameInfo)
940 .take();
John McCall8ccfcb52009-09-24 19:53:00 +0000941
John McCallfeb624a2010-11-23 20:48:44 +0000942 // All the implicit accesses are dot-accesses.
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000943 BaseObjectIsPointer = false;
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000944 }
945
Sebastian Redlffbcf962009-01-18 18:53:16 +0000946 return Owned(Result);
Douglas Gregor9ac7a072009-01-07 00:43:41 +0000947}
948
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000949/// Decomposes the given name into a DeclarationNameInfo, its location, and
John McCall10eae182009-11-30 22:42:35 +0000950/// possibly a list of template arguments.
951///
952/// If this produces template arguments, it is permitted to call
953/// DecomposeTemplateName.
954///
955/// This actually loses a lot of source location information for
956/// non-standard name kinds; we should consider preserving that in
957/// some way.
958static void DecomposeUnqualifiedId(Sema &SemaRef,
959 const UnqualifiedId &Id,
960 TemplateArgumentListInfo &Buffer,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000961 DeclarationNameInfo &NameInfo,
John McCall10eae182009-11-30 22:42:35 +0000962 const TemplateArgumentListInfo *&TemplateArgs) {
963 if (Id.getKind() == UnqualifiedId::IK_TemplateId) {
964 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
965 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
966
967 ASTTemplateArgsPtr TemplateArgsPtr(SemaRef,
968 Id.TemplateId->getTemplateArgs(),
969 Id.TemplateId->NumArgs);
970 SemaRef.translateTemplateArguments(TemplateArgsPtr, Buffer);
971 TemplateArgsPtr.release();
972
John McCall3e56fd42010-08-23 07:28:44 +0000973 TemplateName TName = Id.TemplateId->Template.get();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000974 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
975 NameInfo = SemaRef.Context.getNameForTemplate(TName, TNameLoc);
John McCall10eae182009-11-30 22:42:35 +0000976 TemplateArgs = &Buffer;
977 } else {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000978 NameInfo = SemaRef.GetNameFromUnqualifiedId(Id);
John McCall10eae182009-11-30 22:42:35 +0000979 TemplateArgs = 0;
980 }
981}
982
John McCall69f9dbc2010-02-08 19:26:07 +0000983/// Determines whether the given record is "fully-formed" at the given
984/// location, i.e. whether a qualified lookup into it is assured of
985/// getting consistent results already.
John McCall10eae182009-11-30 22:42:35 +0000986static bool IsFullyFormedScope(Sema &SemaRef, CXXRecordDecl *Record) {
John McCall69f9dbc2010-02-08 19:26:07 +0000987 if (!Record->hasDefinition())
988 return false;
989
John McCall10eae182009-11-30 22:42:35 +0000990 for (CXXRecordDecl::base_class_iterator I = Record->bases_begin(),
991 E = Record->bases_end(); I != E; ++I) {
992 CanQualType BaseT = SemaRef.Context.getCanonicalType((*I).getType());
993 CanQual<RecordType> BaseRT = BaseT->getAs<RecordType>();
994 if (!BaseRT) return false;
995
996 CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(BaseRT->getDecl());
John McCall69f9dbc2010-02-08 19:26:07 +0000997 if (!BaseRecord->hasDefinition() ||
John McCall10eae182009-11-30 22:42:35 +0000998 !IsFullyFormedScope(SemaRef, BaseRecord))
999 return false;
1000 }
1001
1002 return true;
1003}
1004
John McCall2d74de92009-12-01 22:10:20 +00001005/// Determines if the given class is provably not derived from all of
1006/// the prospective base classes.
1007static bool IsProvablyNotDerivedFrom(Sema &SemaRef,
1008 CXXRecordDecl *Record,
1009 const llvm::SmallPtrSet<CXXRecordDecl*, 4> &Bases) {
John McCalla6d407c2009-12-01 22:28:41 +00001010 if (Bases.count(Record->getCanonicalDecl()))
John McCall2d74de92009-12-01 22:10:20 +00001011 return false;
1012
Douglas Gregor0a5a2212010-02-11 01:04:33 +00001013 RecordDecl *RD = Record->getDefinition();
John McCalla6d407c2009-12-01 22:28:41 +00001014 if (!RD) return false;
1015 Record = cast<CXXRecordDecl>(RD);
1016
John McCall2d74de92009-12-01 22:10:20 +00001017 for (CXXRecordDecl::base_class_iterator I = Record->bases_begin(),
1018 E = Record->bases_end(); I != E; ++I) {
1019 CanQualType BaseT = SemaRef.Context.getCanonicalType((*I).getType());
1020 CanQual<RecordType> BaseRT = BaseT->getAs<RecordType>();
1021 if (!BaseRT) return false;
1022
1023 CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(BaseRT->getDecl());
John McCall2d74de92009-12-01 22:10:20 +00001024 if (!IsProvablyNotDerivedFrom(SemaRef, BaseRecord, Bases))
1025 return false;
1026 }
1027
1028 return true;
1029}
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001030
John McCall2d74de92009-12-01 22:10:20 +00001031enum IMAKind {
1032 /// The reference is definitely not an instance member access.
1033 IMA_Static,
1034
1035 /// The reference may be an implicit instance member access.
1036 IMA_Mixed,
1037
1038 /// The reference may be to an instance member, but it is invalid if
1039 /// so, because the context is not an instance method.
1040 IMA_Mixed_StaticContext,
1041
1042 /// The reference may be to an instance member, but it is invalid if
1043 /// so, because the context is from an unrelated class.
1044 IMA_Mixed_Unrelated,
1045
1046 /// The reference is definitely an implicit instance member access.
1047 IMA_Instance,
1048
1049 /// The reference may be to an unresolved using declaration.
1050 IMA_Unresolved,
1051
1052 /// The reference may be to an unresolved using declaration and the
1053 /// context is not an instance method.
1054 IMA_Unresolved_StaticContext,
1055
John McCall2d74de92009-12-01 22:10:20 +00001056 /// All possible referrents are instance members and the current
1057 /// context is not an instance method.
1058 IMA_Error_StaticContext,
1059
1060 /// All possible referrents are instance members of an unrelated
1061 /// class.
1062 IMA_Error_Unrelated
1063};
1064
1065/// The given lookup names class member(s) and is not being used for
1066/// an address-of-member expression. Classify the type of access
1067/// according to whether it's possible that this reference names an
1068/// instance member. This is best-effort; it is okay to
1069/// conservatively answer "yes", in which case some errors will simply
1070/// not be caught until template-instantiation.
1071static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef,
1072 const LookupResult &R) {
John McCall57500772009-12-16 12:17:52 +00001073 assert(!R.empty() && (*R.begin())->isCXXClassMember());
John McCall2d74de92009-12-01 22:10:20 +00001074
John McCall87fe5d52010-05-20 01:18:31 +00001075 DeclContext *DC = SemaRef.getFunctionLevelDeclContext();
John McCall2d74de92009-12-01 22:10:20 +00001076 bool isStaticContext =
John McCall87fe5d52010-05-20 01:18:31 +00001077 (!isa<CXXMethodDecl>(DC) ||
1078 cast<CXXMethodDecl>(DC)->isStatic());
John McCall2d74de92009-12-01 22:10:20 +00001079
1080 if (R.isUnresolvableResult())
1081 return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved;
1082
1083 // Collect all the declaring classes of instance members we find.
1084 bool hasNonInstance = false;
Sebastian Redl34620312010-11-26 16:28:07 +00001085 bool hasField = false;
John McCall2d74de92009-12-01 22:10:20 +00001086 llvm::SmallPtrSet<CXXRecordDecl*, 4> Classes;
1087 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
John McCalla8ae2222010-04-06 21:38:20 +00001088 NamedDecl *D = *I;
Francois Pichet783dd6e2010-11-21 06:08:52 +00001089
John McCalla8ae2222010-04-06 21:38:20 +00001090 if (D->isCXXInstanceMember()) {
Sebastian Redl34620312010-11-26 16:28:07 +00001091 if (dyn_cast<FieldDecl>(D))
1092 hasField = true;
1093
John McCall2d74de92009-12-01 22:10:20 +00001094 CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext());
John McCall2d74de92009-12-01 22:10:20 +00001095 Classes.insert(R->getCanonicalDecl());
1096 }
1097 else
1098 hasNonInstance = true;
1099 }
1100
1101 // If we didn't find any instance members, it can't be an implicit
1102 // member reference.
1103 if (Classes.empty())
1104 return IMA_Static;
1105
1106 // If the current context is not an instance method, it can't be
1107 // an implicit member reference.
Sebastian Redl34620312010-11-26 16:28:07 +00001108 if (isStaticContext) {
1109 if (hasNonInstance)
1110 return IMA_Mixed_StaticContext;
1111
1112 if (SemaRef.getLangOptions().CPlusPlus0x && hasField) {
1113 // C++0x [expr.prim.general]p10:
1114 // An id-expression that denotes a non-static data member or non-static
1115 // member function of a class can only be used:
1116 // (...)
1117 // - if that id-expression denotes a non-static data member and it appears in an unevaluated operand.
1118 const Sema::ExpressionEvaluationContextRecord& record = SemaRef.ExprEvalContexts.back();
1119 bool isUnevaluatedExpression = record.Context == Sema::Unevaluated;
1120 if (isUnevaluatedExpression)
1121 return IMA_Mixed_StaticContext;
1122 }
1123
1124 return IMA_Error_StaticContext;
1125 }
John McCall2d74de92009-12-01 22:10:20 +00001126
1127 // If we can prove that the current context is unrelated to all the
1128 // declaring classes, it can't be an implicit member reference (in
1129 // which case it's an error if any of those members are selected).
1130 if (IsProvablyNotDerivedFrom(SemaRef,
John McCall87fe5d52010-05-20 01:18:31 +00001131 cast<CXXMethodDecl>(DC)->getParent(),
John McCall2d74de92009-12-01 22:10:20 +00001132 Classes))
1133 return (hasNonInstance ? IMA_Mixed_Unrelated : IMA_Error_Unrelated);
1134
1135 return (hasNonInstance ? IMA_Mixed : IMA_Instance);
1136}
1137
1138/// Diagnose a reference to a field with no object available.
1139static void DiagnoseInstanceReference(Sema &SemaRef,
1140 const CXXScopeSpec &SS,
1141 const LookupResult &R) {
1142 SourceLocation Loc = R.getNameLoc();
1143 SourceRange Range(Loc);
1144 if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
1145
1146 if (R.getAsSingle<FieldDecl>()) {
1147 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(SemaRef.CurContext)) {
1148 if (MD->isStatic()) {
1149 // "invalid use of member 'x' in static member function"
1150 SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
1151 << Range << R.getLookupName();
1152 return;
1153 }
1154 }
1155
1156 SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
1157 << R.getLookupName() << Range;
1158 return;
1159 }
1160
1161 SemaRef.Diag(Loc, diag::err_member_call_without_object) << Range;
John McCall10eae182009-11-30 22:42:35 +00001162}
1163
John McCalld681c392009-12-16 08:11:27 +00001164/// Diagnose an empty lookup.
1165///
1166/// \return false if new lookup candidates were found
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001167bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
1168 CorrectTypoContext CTC) {
John McCalld681c392009-12-16 08:11:27 +00001169 DeclarationName Name = R.getLookupName();
1170
John McCalld681c392009-12-16 08:11:27 +00001171 unsigned diagnostic = diag::err_undeclared_var_use;
Douglas Gregor598b08f2009-12-31 05:20:13 +00001172 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
John McCalld681c392009-12-16 08:11:27 +00001173 if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
1174 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName ||
Douglas Gregor598b08f2009-12-31 05:20:13 +00001175 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
John McCalld681c392009-12-16 08:11:27 +00001176 diagnostic = diag::err_undeclared_use;
Douglas Gregor598b08f2009-12-31 05:20:13 +00001177 diagnostic_suggest = diag::err_undeclared_use_suggest;
1178 }
John McCalld681c392009-12-16 08:11:27 +00001179
Douglas Gregor598b08f2009-12-31 05:20:13 +00001180 // If the original lookup was an unqualified lookup, fake an
1181 // unqualified lookup. This is useful when (for example) the
1182 // original lookup would not have found something because it was a
1183 // dependent name.
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001184 for (DeclContext *DC = SS.isEmpty() ? CurContext : 0;
Douglas Gregor598b08f2009-12-31 05:20:13 +00001185 DC; DC = DC->getParent()) {
John McCalld681c392009-12-16 08:11:27 +00001186 if (isa<CXXRecordDecl>(DC)) {
1187 LookupQualifiedName(R, DC);
1188
1189 if (!R.empty()) {
1190 // Don't give errors about ambiguities in this lookup.
1191 R.suppressDiagnostics();
1192
1193 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1194 bool isInstance = CurMethod &&
1195 CurMethod->isInstance() &&
1196 DC == CurMethod->getParent();
1197
1198 // Give a code modification hint to insert 'this->'.
1199 // TODO: fixit for inserting 'Base<T>::' in the other cases.
1200 // Actually quite difficult!
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001201 if (isInstance) {
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001202 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(
1203 CallsUndergoingInstantiation.back()->getCallee());
Nick Lewyckyfe712382010-08-20 20:54:15 +00001204 CXXMethodDecl *DepMethod = cast_or_null<CXXMethodDecl>(
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001205 CurMethod->getInstantiatedFromMemberFunction());
Eli Friedman04831922010-08-22 01:00:03 +00001206 if (DepMethod) {
Nick Lewyckyfe712382010-08-20 20:54:15 +00001207 Diag(R.getNameLoc(), diagnostic) << Name
1208 << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
1209 QualType DepThisType = DepMethod->getThisType(Context);
1210 CXXThisExpr *DepThis = new (Context) CXXThisExpr(
1211 R.getNameLoc(), DepThisType, false);
1212 TemplateArgumentListInfo TList;
1213 if (ULE->hasExplicitTemplateArgs())
1214 ULE->copyTemplateArgumentsInto(TList);
1215 CXXDependentScopeMemberExpr *DepExpr =
1216 CXXDependentScopeMemberExpr::Create(
1217 Context, DepThis, DepThisType, true, SourceLocation(),
1218 ULE->getQualifier(), ULE->getQualifierRange(), NULL,
1219 R.getLookupNameInfo(), &TList);
1220 CallsUndergoingInstantiation.back()->setCallee(DepExpr);
Eli Friedman04831922010-08-22 01:00:03 +00001221 } else {
Nick Lewyckyfe712382010-08-20 20:54:15 +00001222 // FIXME: we should be able to handle this case too. It is correct
1223 // to add this-> here. This is a workaround for PR7947.
1224 Diag(R.getNameLoc(), diagnostic) << Name;
Eli Friedman04831922010-08-22 01:00:03 +00001225 }
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001226 } else {
John McCalld681c392009-12-16 08:11:27 +00001227 Diag(R.getNameLoc(), diagnostic) << Name;
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001228 }
John McCalld681c392009-12-16 08:11:27 +00001229
1230 // Do we really want to note all of these?
1231 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
1232 Diag((*I)->getLocation(), diag::note_dependent_var_use);
1233
1234 // Tell the callee to try to recover.
1235 return false;
1236 }
Douglas Gregor86b8d9f2010-08-09 22:38:14 +00001237
1238 R.clear();
John McCalld681c392009-12-16 08:11:27 +00001239 }
1240 }
1241
Douglas Gregor598b08f2009-12-31 05:20:13 +00001242 // We didn't find anything, so try to correct for a typo.
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001243 DeclarationName Corrected;
Daniel Dunbarf7ced252010-06-02 15:46:52 +00001244 if (S && (Corrected = CorrectTypo(R, S, &SS, 0, false, CTC))) {
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001245 if (!R.empty()) {
1246 if (isa<ValueDecl>(*R.begin()) || isa<FunctionTemplateDecl>(*R.begin())) {
1247 if (SS.isEmpty())
1248 Diag(R.getNameLoc(), diagnostic_suggest) << Name << R.getLookupName()
1249 << FixItHint::CreateReplacement(R.getNameLoc(),
1250 R.getLookupName().getAsString());
1251 else
1252 Diag(R.getNameLoc(), diag::err_no_member_suggest)
1253 << Name << computeDeclContext(SS, false) << R.getLookupName()
1254 << SS.getRange()
1255 << FixItHint::CreateReplacement(R.getNameLoc(),
1256 R.getLookupName().getAsString());
1257 if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
1258 Diag(ND->getLocation(), diag::note_previous_decl)
1259 << ND->getDeclName();
1260
1261 // Tell the callee to try to recover.
1262 return false;
1263 }
Alexis Huntc46382e2010-04-28 23:02:27 +00001264
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001265 if (isa<TypeDecl>(*R.begin()) || isa<ObjCInterfaceDecl>(*R.begin())) {
1266 // FIXME: If we ended up with a typo for a type name or
1267 // Objective-C class name, we're in trouble because the parser
1268 // is in the wrong place to recover. Suggest the typo
1269 // correction, but don't make it a fix-it since we're not going
1270 // to recover well anyway.
1271 if (SS.isEmpty())
1272 Diag(R.getNameLoc(), diagnostic_suggest) << Name << R.getLookupName();
1273 else
1274 Diag(R.getNameLoc(), diag::err_no_member_suggest)
1275 << Name << computeDeclContext(SS, false) << R.getLookupName()
1276 << SS.getRange();
1277
1278 // Don't try to recover; it won't work.
1279 return true;
1280 }
1281 } else {
Alexis Huntc46382e2010-04-28 23:02:27 +00001282 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001283 // because we aren't able to recover.
Douglas Gregor25363982010-01-01 00:15:04 +00001284 if (SS.isEmpty())
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001285 Diag(R.getNameLoc(), diagnostic_suggest) << Name << Corrected;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001286 else
Douglas Gregor25363982010-01-01 00:15:04 +00001287 Diag(R.getNameLoc(), diag::err_no_member_suggest)
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001288 << Name << computeDeclContext(SS, false) << Corrected
1289 << SS.getRange();
Douglas Gregor25363982010-01-01 00:15:04 +00001290 return true;
1291 }
Douglas Gregor25363982010-01-01 00:15:04 +00001292 R.clear();
Douglas Gregor598b08f2009-12-31 05:20:13 +00001293 }
1294
1295 // Emit a special diagnostic for failed member lookups.
1296 // FIXME: computing the declaration context might fail here (?)
1297 if (!SS.isEmpty()) {
1298 Diag(R.getNameLoc(), diag::err_no_member)
1299 << Name << computeDeclContext(SS, false)
1300 << SS.getRange();
1301 return true;
1302 }
1303
John McCalld681c392009-12-16 08:11:27 +00001304 // Give up, we can't recover.
1305 Diag(R.getNameLoc(), diagnostic) << Name;
1306 return true;
1307}
1308
Douglas Gregor05fcf842010-11-02 20:36:02 +00001309ObjCPropertyDecl *Sema::canSynthesizeProvisionalIvar(IdentifierInfo *II) {
1310 ObjCMethodDecl *CurMeth = getCurMethodDecl();
Fariborz Jahanian86151342010-07-22 23:33:21 +00001311 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface();
1312 if (!IDecl)
1313 return 0;
1314 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation();
1315 if (!ClassImpDecl)
1316 return 0;
Douglas Gregor05fcf842010-11-02 20:36:02 +00001317 ObjCPropertyDecl *property = LookupPropertyDecl(IDecl, II);
Fariborz Jahanian86151342010-07-22 23:33:21 +00001318 if (!property)
1319 return 0;
1320 if (ObjCPropertyImplDecl *PIDecl = ClassImpDecl->FindPropertyImplDecl(II))
Douglas Gregor05fcf842010-11-02 20:36:02 +00001321 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic ||
1322 PIDecl->getPropertyIvarDecl())
Fariborz Jahanian86151342010-07-22 23:33:21 +00001323 return 0;
1324 return property;
1325}
1326
Douglas Gregor05fcf842010-11-02 20:36:02 +00001327bool Sema::canSynthesizeProvisionalIvar(ObjCPropertyDecl *Property) {
1328 ObjCMethodDecl *CurMeth = getCurMethodDecl();
1329 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface();
1330 if (!IDecl)
1331 return false;
1332 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation();
1333 if (!ClassImpDecl)
1334 return false;
1335 if (ObjCPropertyImplDecl *PIDecl
1336 = ClassImpDecl->FindPropertyImplDecl(Property->getIdentifier()))
1337 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic ||
1338 PIDecl->getPropertyIvarDecl())
1339 return false;
1340
1341 return true;
1342}
1343
Fariborz Jahanian18722982010-07-17 00:59:30 +00001344static ObjCIvarDecl *SynthesizeProvisionalIvar(Sema &SemaRef,
Fariborz Jahanian7b70eb42010-07-30 16:59:05 +00001345 LookupResult &Lookup,
Fariborz Jahanian18722982010-07-17 00:59:30 +00001346 IdentifierInfo *II,
1347 SourceLocation NameLoc) {
1348 ObjCMethodDecl *CurMeth = SemaRef.getCurMethodDecl();
Fariborz Jahanian7b70eb42010-07-30 16:59:05 +00001349 bool LookForIvars;
1350 if (Lookup.empty())
1351 LookForIvars = true;
1352 else if (CurMeth->isClassMethod())
1353 LookForIvars = false;
1354 else
1355 LookForIvars = (Lookup.isSingleResult() &&
1356 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod());
1357 if (!LookForIvars)
1358 return 0;
1359
Fariborz Jahanian18722982010-07-17 00:59:30 +00001360 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface();
1361 if (!IDecl)
1362 return 0;
1363 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation();
Fariborz Jahanian2a360892010-07-19 16:14:33 +00001364 if (!ClassImpDecl)
1365 return 0;
Fariborz Jahanian18722982010-07-17 00:59:30 +00001366 bool DynamicImplSeen = false;
1367 ObjCPropertyDecl *property = SemaRef.LookupPropertyDecl(IDecl, II);
1368 if (!property)
1369 return 0;
Fariborz Jahanianbfcbc852010-10-19 19:08:23 +00001370 if (ObjCPropertyImplDecl *PIDecl = ClassImpDecl->FindPropertyImplDecl(II)) {
Fariborz Jahanian18722982010-07-17 00:59:30 +00001371 DynamicImplSeen =
1372 (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
Fariborz Jahanianbfcbc852010-10-19 19:08:23 +00001373 // property implementation has a designated ivar. No need to assume a new
1374 // one.
1375 if (!DynamicImplSeen && PIDecl->getPropertyIvarDecl())
1376 return 0;
1377 }
Fariborz Jahanian18722982010-07-17 00:59:30 +00001378 if (!DynamicImplSeen) {
Fariborz Jahanian2a360892010-07-19 16:14:33 +00001379 QualType PropType = SemaRef.Context.getCanonicalType(property->getType());
1380 ObjCIvarDecl *Ivar = ObjCIvarDecl::Create(SemaRef.Context, ClassImpDecl,
Fariborz Jahanian18722982010-07-17 00:59:30 +00001381 NameLoc,
1382 II, PropType, /*Dinfo=*/0,
Fariborz Jahanian522eb7b2010-12-15 23:29:04 +00001383 ObjCIvarDecl::Private,
Fariborz Jahanian18722982010-07-17 00:59:30 +00001384 (Expr *)0, true);
1385 ClassImpDecl->addDecl(Ivar);
1386 IDecl->makeDeclVisibleInContext(Ivar, false);
1387 property->setPropertyIvarDecl(Ivar);
1388 return Ivar;
1389 }
1390 return 0;
1391}
1392
John McCalldadc5752010-08-24 06:29:42 +00001393ExprResult Sema::ActOnIdExpression(Scope *S,
John McCall24d18942010-08-24 22:52:39 +00001394 CXXScopeSpec &SS,
1395 UnqualifiedId &Id,
1396 bool HasTrailingLParen,
1397 bool isAddressOfOperand) {
John McCalle66edc12009-11-24 19:00:30 +00001398 assert(!(isAddressOfOperand && HasTrailingLParen) &&
1399 "cannot be direct & operand and have a trailing lparen");
1400
1401 if (SS.isInvalid())
Douglas Gregored8f2882009-01-30 01:04:22 +00001402 return ExprError();
Douglas Gregor90a1a652009-03-19 17:26:29 +00001403
John McCall10eae182009-11-30 22:42:35 +00001404 TemplateArgumentListInfo TemplateArgsBuffer;
John McCalle66edc12009-11-24 19:00:30 +00001405
1406 // Decompose the UnqualifiedId into the following data.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001407 DeclarationNameInfo NameInfo;
John McCalle66edc12009-11-24 19:00:30 +00001408 const TemplateArgumentListInfo *TemplateArgs;
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001409 DecomposeUnqualifiedId(*this, Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
Douglas Gregor90a1a652009-03-19 17:26:29 +00001410
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001411 DeclarationName Name = NameInfo.getName();
Douglas Gregor4ea80432008-11-18 15:03:34 +00001412 IdentifierInfo *II = Name.getAsIdentifierInfo();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001413 SourceLocation NameLoc = NameInfo.getLoc();
John McCalld14a8642009-11-21 08:51:07 +00001414
John McCalle66edc12009-11-24 19:00:30 +00001415 // C++ [temp.dep.expr]p3:
1416 // An id-expression is type-dependent if it contains:
Douglas Gregorea0a0a92010-01-11 18:40:55 +00001417 // -- an identifier that was declared with a dependent type,
1418 // (note: handled after lookup)
1419 // -- a template-id that is dependent,
1420 // (note: handled in BuildTemplateIdExpr)
1421 // -- a conversion-function-id that specifies a dependent type,
John McCalle66edc12009-11-24 19:00:30 +00001422 // -- a nested-name-specifier that contains a class-name that
1423 // names a dependent type.
1424 // Determine whether this is a member of an unknown specialization;
1425 // we need to handle these differently.
Eli Friedman964dbda2010-08-06 23:41:47 +00001426 bool DependentID = false;
1427 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1428 Name.getCXXNameType()->isDependentType()) {
1429 DependentID = true;
1430 } else if (SS.isSet()) {
1431 DeclContext *DC = computeDeclContext(SS, false);
1432 if (DC) {
1433 if (RequireCompleteDeclContext(SS, DC))
1434 return ExprError();
1435 // FIXME: We should be checking whether DC is the current instantiation.
1436 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
1437 DependentID = !IsFullyFormedScope(*this, RD);
1438 } else {
1439 DependentID = true;
1440 }
1441 }
1442
1443 if (DependentID) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001444 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand,
John McCalle66edc12009-11-24 19:00:30 +00001445 TemplateArgs);
1446 }
Fariborz Jahanian86151342010-07-22 23:33:21 +00001447 bool IvarLookupFollowUp = false;
John McCalle66edc12009-11-24 19:00:30 +00001448 // Perform the required lookup.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001449 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCalle66edc12009-11-24 19:00:30 +00001450 if (TemplateArgs) {
Douglas Gregor3e51e172010-05-20 20:58:56 +00001451 // Lookup the template name again to correctly establish the context in
1452 // which it was found. This is really unfortunate as we already did the
1453 // lookup to determine that it was a template name in the first place. If
1454 // this becomes a performance hit, we can work harder to preserve those
1455 // results until we get here but it's likely not worth it.
Douglas Gregor786123d2010-05-21 23:18:07 +00001456 bool MemberOfUnknownSpecialization;
1457 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
1458 MemberOfUnknownSpecialization);
John McCalle66edc12009-11-24 19:00:30 +00001459 } else {
Fariborz Jahanian86151342010-07-22 23:33:21 +00001460 IvarLookupFollowUp = (!SS.isSet() && II && getCurMethodDecl());
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00001461 LookupParsedName(R, S, &SS, !IvarLookupFollowUp);
Mike Stump11289f42009-09-09 15:08:12 +00001462
John McCalle66edc12009-11-24 19:00:30 +00001463 // If this reference is in an Objective-C method, then we need to do
1464 // some special Objective-C lookup, too.
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00001465 if (IvarLookupFollowUp) {
John McCalldadc5752010-08-24 06:29:42 +00001466 ExprResult E(LookupInObjCMethod(R, S, II, true));
John McCalle66edc12009-11-24 19:00:30 +00001467 if (E.isInvalid())
1468 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00001469
John McCalle66edc12009-11-24 19:00:30 +00001470 Expr *Ex = E.takeAs<Expr>();
1471 if (Ex) return Owned(Ex);
Fariborz Jahanian18722982010-07-17 00:59:30 +00001472 // Synthesize ivars lazily
Fariborz Jahanianc63f1c52011-01-03 18:08:02 +00001473 if (getLangOptions().ObjCDefaultSynthProperties &&
1474 getLangOptions().ObjCNonFragileABI2) {
Fariborz Jahanian8046af72010-11-17 19:41:23 +00001475 if (SynthesizeProvisionalIvar(*this, R, II, NameLoc)) {
1476 if (const ObjCPropertyDecl *Property =
1477 canSynthesizeProvisionalIvar(II)) {
1478 Diag(NameLoc, diag::warn_synthesized_ivar_access) << II;
1479 Diag(Property->getLocation(), diag::note_property_declare);
1480 }
Fariborz Jahanian18722982010-07-17 00:59:30 +00001481 return ActOnIdExpression(S, SS, Id, HasTrailingLParen,
1482 isAddressOfOperand);
Fariborz Jahanian8046af72010-11-17 19:41:23 +00001483 }
Fariborz Jahanian18722982010-07-17 00:59:30 +00001484 }
Fariborz Jahanian18d90a92010-08-13 18:09:39 +00001485 // for further use, this must be set to false if in class method.
1486 IvarLookupFollowUp = getCurMethodDecl()->isInstanceMethod();
Steve Naroffebf4cb42008-06-02 23:03:37 +00001487 }
Chris Lattner59a25942008-03-31 00:36:02 +00001488 }
Douglas Gregorf15f5d32009-02-16 19:28:42 +00001489
John McCalle66edc12009-11-24 19:00:30 +00001490 if (R.isAmbiguous())
1491 return ExprError();
1492
Douglas Gregor171c45a2009-02-18 21:56:37 +00001493 // Determine whether this name might be a candidate for
1494 // argument-dependent lookup.
John McCalle66edc12009-11-24 19:00:30 +00001495 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
Douglas Gregor171c45a2009-02-18 21:56:37 +00001496
John McCalle66edc12009-11-24 19:00:30 +00001497 if (R.empty() && !ADL) {
Bill Wendling4073ed52007-02-13 01:51:42 +00001498 // Otherwise, this could be an implicitly declared function reference (legal
John McCalle66edc12009-11-24 19:00:30 +00001499 // in C90, extension in C99, forbidden in C++).
1500 if (HasTrailingLParen && II && !getLangOptions().CPlusPlus) {
1501 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
1502 if (D) R.addDecl(D);
1503 }
1504
1505 // If this name wasn't predeclared and if this is not a function
1506 // call, diagnose the problem.
1507 if (R.empty()) {
Douglas Gregor5fd04d42010-05-18 16:14:23 +00001508 if (DiagnoseEmptyLookup(S, SS, R, CTC_Unknown))
John McCalld681c392009-12-16 08:11:27 +00001509 return ExprError();
1510
1511 assert(!R.empty() &&
1512 "DiagnoseEmptyLookup returned false but added no results");
Douglas Gregor35b0bac2010-01-03 18:01:57 +00001513
1514 // If we found an Objective-C instance variable, let
1515 // LookupInObjCMethod build the appropriate expression to
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001516 // reference the ivar.
Douglas Gregor35b0bac2010-01-03 18:01:57 +00001517 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
1518 R.clear();
John McCalldadc5752010-08-24 06:29:42 +00001519 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier()));
Douglas Gregor35b0bac2010-01-03 18:01:57 +00001520 assert(E.isInvalid() || E.get());
1521 return move(E);
1522 }
Steve Naroff92e30f82007-04-02 22:35:25 +00001523 }
Chris Lattner17ed4872006-11-20 04:58:19 +00001524 }
Mike Stump11289f42009-09-09 15:08:12 +00001525
John McCalle66edc12009-11-24 19:00:30 +00001526 // This is guaranteed from this point on.
1527 assert(!R.empty() || ADL);
1528
1529 if (VarDecl *Var = R.getAsSingle<VarDecl>()) {
Fariborz Jahanian86151342010-07-22 23:33:21 +00001530 if (getLangOptions().ObjCNonFragileABI && IvarLookupFollowUp &&
Fariborz Jahanianc63f1c52011-01-03 18:08:02 +00001531 !(getLangOptions().ObjCDefaultSynthProperties &&
1532 getLangOptions().ObjCNonFragileABI2) &&
Fariborz Jahanianc15dfd82010-07-29 16:53:53 +00001533 Var->isFileVarDecl()) {
Douglas Gregor05fcf842010-11-02 20:36:02 +00001534 ObjCPropertyDecl *Property = canSynthesizeProvisionalIvar(II);
Fariborz Jahanian86151342010-07-22 23:33:21 +00001535 if (Property) {
1536 Diag(NameLoc, diag::warn_ivar_variable_conflict) << Var->getDeclName();
1537 Diag(Property->getLocation(), diag::note_property_declare);
Fariborz Jahanian18d90a92010-08-13 18:09:39 +00001538 Diag(Var->getLocation(), diag::note_global_declared_at);
Fariborz Jahanian86151342010-07-22 23:33:21 +00001539 }
1540 }
John McCalle66edc12009-11-24 19:00:30 +00001541 } else if (FunctionDecl *Func = R.getAsSingle<FunctionDecl>()) {
Douglas Gregor3256d042009-06-30 15:47:41 +00001542 if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) {
1543 // C99 DR 316 says that, if a function type comes from a
1544 // function definition (without a prototype), that type is only
1545 // used for checking compatibility. Therefore, when referencing
1546 // the function, we pretend that we don't have the full function
1547 // type.
John McCalle66edc12009-11-24 19:00:30 +00001548 if (DiagnoseUseOfDecl(Func, NameLoc))
Douglas Gregor3256d042009-06-30 15:47:41 +00001549 return ExprError();
Douglas Gregor9ac7a072009-01-07 00:43:41 +00001550
Douglas Gregor3256d042009-06-30 15:47:41 +00001551 QualType T = Func->getType();
1552 QualType NoProtoType = T;
John McCall9dd450b2009-09-21 23:43:11 +00001553 if (const FunctionProtoType *Proto = T->getAs<FunctionProtoType>())
Eli Friedmanb41ad0f2010-05-17 02:50:18 +00001554 NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType(),
1555 Proto->getExtInfo());
John McCall7decc9e2010-11-18 06:31:45 +00001556 // Note that functions are r-values in C.
1557 return BuildDeclRefExpr(Func, NoProtoType, VK_RValue, NameLoc, &SS);
Douglas Gregor3256d042009-06-30 15:47:41 +00001558 }
1559 }
Mike Stump11289f42009-09-09 15:08:12 +00001560
John McCall2d74de92009-12-01 22:10:20 +00001561 // Check whether this might be a C++ implicit instance member access.
John McCall24d18942010-08-24 22:52:39 +00001562 // C++ [class.mfct.non-static]p3:
1563 // When an id-expression that is not part of a class member access
1564 // syntax and not used to form a pointer to member is used in the
1565 // body of a non-static member function of class X, if name lookup
1566 // resolves the name in the id-expression to a non-static non-type
1567 // member of some class C, the id-expression is transformed into a
1568 // class member access expression using (*this) as the
1569 // postfix-expression to the left of the . operator.
John McCall8d08b9b2010-08-27 09:08:28 +00001570 //
1571 // But we don't actually need to do this for '&' operands if R
1572 // resolved to a function or overloaded function set, because the
1573 // expression is ill-formed if it actually works out to be a
1574 // non-static member function:
1575 //
1576 // C++ [expr.ref]p4:
1577 // Otherwise, if E1.E2 refers to a non-static member function. . .
1578 // [t]he expression can be used only as the left-hand operand of a
1579 // member function call.
1580 //
1581 // There are other safeguards against such uses, but it's important
1582 // to get this right here so that we don't end up making a
1583 // spuriously dependent expression if we're inside a dependent
1584 // instance method.
John McCall57500772009-12-16 12:17:52 +00001585 if (!R.empty() && (*R.begin())->isCXXClassMember()) {
John McCall8d08b9b2010-08-27 09:08:28 +00001586 bool MightBeImplicitMember;
1587 if (!isAddressOfOperand)
1588 MightBeImplicitMember = true;
1589 else if (!SS.isEmpty())
1590 MightBeImplicitMember = false;
1591 else if (R.isOverloadedResult())
1592 MightBeImplicitMember = false;
Douglas Gregor1262b062010-08-30 16:00:47 +00001593 else if (R.isUnresolvableResult())
1594 MightBeImplicitMember = true;
John McCall8d08b9b2010-08-27 09:08:28 +00001595 else
Francois Pichet783dd6e2010-11-21 06:08:52 +00001596 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) ||
1597 isa<IndirectFieldDecl>(R.getFoundDecl());
John McCall8d08b9b2010-08-27 09:08:28 +00001598
1599 if (MightBeImplicitMember)
John McCall57500772009-12-16 12:17:52 +00001600 return BuildPossibleImplicitMemberExpr(SS, R, TemplateArgs);
John McCallb53bbd42009-11-22 01:44:31 +00001601 }
1602
John McCalle66edc12009-11-24 19:00:30 +00001603 if (TemplateArgs)
1604 return BuildTemplateIdExpr(SS, R, ADL, *TemplateArgs);
John McCallb53bbd42009-11-22 01:44:31 +00001605
John McCalle66edc12009-11-24 19:00:30 +00001606 return BuildDeclarationNameExpr(SS, R, ADL);
1607}
1608
John McCall57500772009-12-16 12:17:52 +00001609/// Builds an expression which might be an implicit member expression.
John McCalldadc5752010-08-24 06:29:42 +00001610ExprResult
John McCall57500772009-12-16 12:17:52 +00001611Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
1612 LookupResult &R,
1613 const TemplateArgumentListInfo *TemplateArgs) {
1614 switch (ClassifyImplicitMemberAccess(*this, R)) {
1615 case IMA_Instance:
1616 return BuildImplicitMemberExpr(SS, R, TemplateArgs, true);
1617
John McCall57500772009-12-16 12:17:52 +00001618 case IMA_Mixed:
1619 case IMA_Mixed_Unrelated:
1620 case IMA_Unresolved:
1621 return BuildImplicitMemberExpr(SS, R, TemplateArgs, false);
1622
1623 case IMA_Static:
1624 case IMA_Mixed_StaticContext:
1625 case IMA_Unresolved_StaticContext:
1626 if (TemplateArgs)
1627 return BuildTemplateIdExpr(SS, R, false, *TemplateArgs);
1628 return BuildDeclarationNameExpr(SS, R, false);
1629
1630 case IMA_Error_StaticContext:
1631 case IMA_Error_Unrelated:
1632 DiagnoseInstanceReference(*this, SS, R);
1633 return ExprError();
1634 }
1635
1636 llvm_unreachable("unexpected instance member access kind");
1637 return ExprError();
1638}
1639
John McCall10eae182009-11-30 22:42:35 +00001640/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
1641/// declaration name, generally during template instantiation.
1642/// There's a large number of things which don't need to be done along
1643/// this path.
John McCalldadc5752010-08-24 06:29:42 +00001644ExprResult
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00001645Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001646 const DeclarationNameInfo &NameInfo) {
John McCalle66edc12009-11-24 19:00:30 +00001647 DeclContext *DC;
Douglas Gregora02bb342010-04-28 07:04:26 +00001648 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext())
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001649 return BuildDependentDeclRefExpr(SS, NameInfo, 0);
John McCalle66edc12009-11-24 19:00:30 +00001650
John McCall0b66eb32010-05-01 00:40:08 +00001651 if (RequireCompleteDeclContext(SS, DC))
Douglas Gregora02bb342010-04-28 07:04:26 +00001652 return ExprError();
1653
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001654 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCalle66edc12009-11-24 19:00:30 +00001655 LookupQualifiedName(R, DC);
1656
1657 if (R.isAmbiguous())
1658 return ExprError();
1659
1660 if (R.empty()) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001661 Diag(NameInfo.getLoc(), diag::err_no_member)
1662 << NameInfo.getName() << DC << SS.getRange();
John McCalle66edc12009-11-24 19:00:30 +00001663 return ExprError();
1664 }
1665
1666 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false);
1667}
1668
1669/// LookupInObjCMethod - The parser has read a name in, and Sema has
1670/// detected that we're currently inside an ObjC method. Perform some
1671/// additional lookup.
1672///
1673/// Ideally, most of this would be done by lookup, but there's
1674/// actually quite a lot of extra work involved.
1675///
1676/// Returns a null sentinel to indicate trivial success.
John McCalldadc5752010-08-24 06:29:42 +00001677ExprResult
John McCalle66edc12009-11-24 19:00:30 +00001678Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S,
Chris Lattnera36ec422010-04-11 08:28:14 +00001679 IdentifierInfo *II, bool AllowBuiltinCreation) {
John McCalle66edc12009-11-24 19:00:30 +00001680 SourceLocation Loc = Lookup.getNameLoc();
Chris Lattner87313662010-04-12 05:10:17 +00001681 ObjCMethodDecl *CurMethod = getCurMethodDecl();
Alexis Huntc46382e2010-04-28 23:02:27 +00001682
John McCalle66edc12009-11-24 19:00:30 +00001683 // There are two cases to handle here. 1) scoped lookup could have failed,
1684 // in which case we should look for an ivar. 2) scoped lookup could have
1685 // found a decl, but that decl is outside the current instance method (i.e.
1686 // a global variable). In these two cases, we do a lookup for an ivar with
1687 // this name, if the lookup sucedes, we replace it our current decl.
1688
1689 // If we're in a class method, we don't normally want to look for
1690 // ivars. But if we don't find anything else, and there's an
1691 // ivar, that's an error.
Chris Lattner87313662010-04-12 05:10:17 +00001692 bool IsClassMethod = CurMethod->isClassMethod();
John McCalle66edc12009-11-24 19:00:30 +00001693
1694 bool LookForIvars;
1695 if (Lookup.empty())
1696 LookForIvars = true;
1697 else if (IsClassMethod)
1698 LookForIvars = false;
1699 else
1700 LookForIvars = (Lookup.isSingleResult() &&
1701 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod());
Fariborz Jahanian45878032010-02-09 19:31:38 +00001702 ObjCInterfaceDecl *IFace = 0;
John McCalle66edc12009-11-24 19:00:30 +00001703 if (LookForIvars) {
Chris Lattner87313662010-04-12 05:10:17 +00001704 IFace = CurMethod->getClassInterface();
John McCalle66edc12009-11-24 19:00:30 +00001705 ObjCInterfaceDecl *ClassDeclared;
1706 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
1707 // Diagnose using an ivar in a class method.
1708 if (IsClassMethod)
1709 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
1710 << IV->getDeclName());
1711
1712 // If we're referencing an invalid decl, just return this as a silent
1713 // error node. The error diagnostic was already emitted on the decl.
1714 if (IV->isInvalidDecl())
1715 return ExprError();
1716
1717 // Check if referencing a field with __attribute__((deprecated)).
1718 if (DiagnoseUseOfDecl(IV, Loc))
1719 return ExprError();
1720
1721 // Diagnose the use of an ivar outside of the declaring class.
1722 if (IV->getAccessControl() == ObjCIvarDecl::Private &&
1723 ClassDeclared != IFace)
1724 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
1725
1726 // FIXME: This should use a new expr for a direct reference, don't
1727 // turn this into Self->ivar, just return a BareIVarExpr or something.
1728 IdentifierInfo &II = Context.Idents.get("self");
1729 UnqualifiedId SelfName;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001730 SelfName.setIdentifier(&II, SourceLocation());
John McCalle66edc12009-11-24 19:00:30 +00001731 CXXScopeSpec SelfScopeSpec;
John McCalldadc5752010-08-24 06:29:42 +00001732 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec,
Douglas Gregora1ed39b2010-09-22 16:33:13 +00001733 SelfName, false, false);
1734 if (SelfExpr.isInvalid())
1735 return ExprError();
1736
John McCall27584242010-12-06 20:48:59 +00001737 Expr *SelfE = SelfExpr.take();
1738 DefaultLvalueConversion(SelfE);
1739
John McCalle66edc12009-11-24 19:00:30 +00001740 MarkDeclarationReferenced(Loc, IV);
1741 return Owned(new (Context)
1742 ObjCIvarRefExpr(IV, IV->getType(), Loc,
John McCall27584242010-12-06 20:48:59 +00001743 SelfE, true, true));
John McCalle66edc12009-11-24 19:00:30 +00001744 }
Chris Lattner87313662010-04-12 05:10:17 +00001745 } else if (CurMethod->isInstanceMethod()) {
John McCalle66edc12009-11-24 19:00:30 +00001746 // We should warn if a local variable hides an ivar.
Chris Lattner87313662010-04-12 05:10:17 +00001747 ObjCInterfaceDecl *IFace = CurMethod->getClassInterface();
John McCalle66edc12009-11-24 19:00:30 +00001748 ObjCInterfaceDecl *ClassDeclared;
1749 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
1750 if (IV->getAccessControl() != ObjCIvarDecl::Private ||
1751 IFace == ClassDeclared)
1752 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
1753 }
1754 }
1755
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00001756 if (Lookup.empty() && II && AllowBuiltinCreation) {
1757 // FIXME. Consolidate this with similar code in LookupName.
1758 if (unsigned BuiltinID = II->getBuiltinID()) {
1759 if (!(getLangOptions().CPlusPlus &&
1760 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) {
1761 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
1762 S, Lookup.isForRedeclaration(),
1763 Lookup.getNameLoc());
1764 if (D) Lookup.addDecl(D);
1765 }
1766 }
1767 }
John McCalle66edc12009-11-24 19:00:30 +00001768 // Sentinel value saying that we didn't do anything special.
1769 return Owned((Expr*) 0);
Douglas Gregor3256d042009-06-30 15:47:41 +00001770}
John McCalld14a8642009-11-21 08:51:07 +00001771
John McCall16df1e52010-03-30 21:47:33 +00001772/// \brief Cast a base object to a member's actual type.
1773///
1774/// Logically this happens in three phases:
1775///
1776/// * First we cast from the base type to the naming class.
1777/// The naming class is the class into which we were looking
1778/// when we found the member; it's the qualifier type if a
1779/// qualifier was provided, and otherwise it's the base type.
1780///
1781/// * Next we cast from the naming class to the declaring class.
1782/// If the member we found was brought into a class's scope by
1783/// a using declaration, this is that class; otherwise it's
1784/// the class declaring the member.
1785///
1786/// * Finally we cast from the declaring class to the "true"
1787/// declaring class of the member. This conversion does not
1788/// obey access control.
Fariborz Jahanian3f150832009-07-29 19:40:11 +00001789bool
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001790Sema::PerformObjectMemberConversion(Expr *&From,
1791 NestedNameSpecifier *Qualifier,
John McCall16df1e52010-03-30 21:47:33 +00001792 NamedDecl *FoundDecl,
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001793 NamedDecl *Member) {
1794 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext());
1795 if (!RD)
1796 return false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001797
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001798 QualType DestRecordType;
1799 QualType DestType;
1800 QualType FromRecordType;
1801 QualType FromType = From->getType();
1802 bool PointerConversions = false;
1803 if (isa<FieldDecl>(Member)) {
1804 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD));
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001805
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001806 if (FromType->getAs<PointerType>()) {
1807 DestType = Context.getPointerType(DestRecordType);
1808 FromRecordType = FromType->getPointeeType();
1809 PointerConversions = true;
1810 } else {
1811 DestType = DestRecordType;
1812 FromRecordType = FromType;
Fariborz Jahanianbb67b822009-07-29 18:40:24 +00001813 }
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001814 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) {
1815 if (Method->isStatic())
1816 return false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001817
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001818 DestType = Method->getThisType(Context);
1819 DestRecordType = DestType->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001820
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001821 if (FromType->getAs<PointerType>()) {
1822 FromRecordType = FromType->getPointeeType();
1823 PointerConversions = true;
1824 } else {
1825 FromRecordType = FromType;
1826 DestType = DestRecordType;
1827 }
1828 } else {
1829 // No conversion necessary.
1830 return false;
1831 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001832
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001833 if (DestType->isDependentType() || FromType->isDependentType())
1834 return false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001835
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001836 // If the unqualified types are the same, no conversion is necessary.
1837 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
1838 return false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001839
John McCall16df1e52010-03-30 21:47:33 +00001840 SourceRange FromRange = From->getSourceRange();
1841 SourceLocation FromLoc = FromRange.getBegin();
1842
John McCall2536c6d2010-08-25 10:28:54 +00001843 ExprValueKind VK = CastCategory(From);
Sebastian Redlc57d34b2010-07-20 04:20:21 +00001844
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001845 // C++ [class.member.lookup]p8:
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001846 // [...] Ambiguities can often be resolved by qualifying a name with its
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001847 // class name.
1848 //
1849 // If the member was a qualified name and the qualified referred to a
1850 // specific base subobject type, we'll cast to that intermediate type
1851 // first and then to the object in which the member is declared. That allows
1852 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as:
1853 //
1854 // class Base { public: int x; };
1855 // class Derived1 : public Base { };
1856 // class Derived2 : public Base { };
1857 // class VeryDerived : public Derived1, public Derived2 { void f(); };
1858 //
1859 // void VeryDerived::f() {
1860 // x = 17; // error: ambiguous base subobjects
1861 // Derived1::x = 17; // okay, pick the Base subobject of Derived1
1862 // }
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001863 if (Qualifier) {
John McCall16df1e52010-03-30 21:47:33 +00001864 QualType QType = QualType(Qualifier->getAsType(), 0);
1865 assert(!QType.isNull() && "lookup done with dependent qualifier?");
1866 assert(QType->isRecordType() && "lookup done with non-record type");
1867
1868 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0);
1869
1870 // In C++98, the qualifier type doesn't actually have to be a base
1871 // type of the object type, in which case we just ignore it.
1872 // Otherwise build the appropriate casts.
1873 if (IsDerivedFrom(FromRecordType, QRecordType)) {
John McCallcf142162010-08-07 06:22:56 +00001874 CXXCastPath BasePath;
John McCall16df1e52010-03-30 21:47:33 +00001875 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
Anders Carlssonb78feca2010-04-24 19:22:20 +00001876 FromLoc, FromRange, &BasePath))
John McCall16df1e52010-03-30 21:47:33 +00001877 return true;
1878
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001879 if (PointerConversions)
John McCall16df1e52010-03-30 21:47:33 +00001880 QType = Context.getPointerType(QType);
John McCall2536c6d2010-08-25 10:28:54 +00001881 ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
1882 VK, &BasePath);
John McCall16df1e52010-03-30 21:47:33 +00001883
1884 FromType = QType;
1885 FromRecordType = QRecordType;
1886
1887 // If the qualifier type was the same as the destination type,
1888 // we're done.
1889 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
1890 return false;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001891 }
1892 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001893
John McCall16df1e52010-03-30 21:47:33 +00001894 bool IgnoreAccess = false;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001895
John McCall16df1e52010-03-30 21:47:33 +00001896 // If we actually found the member through a using declaration, cast
1897 // down to the using declaration's type.
1898 //
1899 // Pointer equality is fine here because only one declaration of a
1900 // class ever has member declarations.
1901 if (FoundDecl->getDeclContext() != Member->getDeclContext()) {
1902 assert(isa<UsingShadowDecl>(FoundDecl));
1903 QualType URecordType = Context.getTypeDeclType(
1904 cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
1905
1906 // We only need to do this if the naming-class to declaring-class
1907 // conversion is non-trivial.
1908 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) {
1909 assert(IsDerivedFrom(FromRecordType, URecordType));
John McCallcf142162010-08-07 06:22:56 +00001910 CXXCastPath BasePath;
John McCall16df1e52010-03-30 21:47:33 +00001911 if (CheckDerivedToBaseConversion(FromRecordType, URecordType,
Anders Carlssonb78feca2010-04-24 19:22:20 +00001912 FromLoc, FromRange, &BasePath))
John McCall16df1e52010-03-30 21:47:33 +00001913 return true;
Alexis Huntc46382e2010-04-28 23:02:27 +00001914
John McCall16df1e52010-03-30 21:47:33 +00001915 QualType UType = URecordType;
1916 if (PointerConversions)
1917 UType = Context.getPointerType(UType);
John McCalle3027922010-08-25 11:45:40 +00001918 ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase,
John McCall2536c6d2010-08-25 10:28:54 +00001919 VK, &BasePath);
John McCall16df1e52010-03-30 21:47:33 +00001920 FromType = UType;
1921 FromRecordType = URecordType;
1922 }
1923
1924 // We don't do access control for the conversion from the
1925 // declaring class to the true declaring class.
1926 IgnoreAccess = true;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001927 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001928
John McCallcf142162010-08-07 06:22:56 +00001929 CXXCastPath BasePath;
Anders Carlssonb78feca2010-04-24 19:22:20 +00001930 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
1931 FromLoc, FromRange, &BasePath,
John McCall16df1e52010-03-30 21:47:33 +00001932 IgnoreAccess))
Douglas Gregorcc3f3252010-03-03 23:55:11 +00001933 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001934
John McCalle3027922010-08-25 11:45:40 +00001935 ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase,
John McCall2536c6d2010-08-25 10:28:54 +00001936 VK, &BasePath);
Fariborz Jahanian3f150832009-07-29 19:40:11 +00001937 return false;
Fariborz Jahanianbb67b822009-07-29 18:40:24 +00001938}
Douglas Gregor3256d042009-06-30 15:47:41 +00001939
Douglas Gregorf405d7e2009-08-31 23:41:50 +00001940/// \brief Build a MemberExpr AST node.
Mike Stump11289f42009-09-09 15:08:12 +00001941static MemberExpr *BuildMemberExpr(ASTContext &C, Expr *Base, bool isArrow,
Eli Friedman2cfcef62009-12-04 06:40:45 +00001942 const CXXScopeSpec &SS, ValueDecl *Member,
John McCalla8ae2222010-04-06 21:38:20 +00001943 DeclAccessPair FoundDecl,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001944 const DeclarationNameInfo &MemberNameInfo,
1945 QualType Ty,
John McCall7decc9e2010-11-18 06:31:45 +00001946 ExprValueKind VK, ExprObjectKind OK,
John McCalle66edc12009-11-24 19:00:30 +00001947 const TemplateArgumentListInfo *TemplateArgs = 0) {
1948 NestedNameSpecifier *Qualifier = 0;
1949 SourceRange QualifierRange;
John McCall10eae182009-11-30 22:42:35 +00001950 if (SS.isSet()) {
1951 Qualifier = (NestedNameSpecifier *) SS.getScopeRep();
1952 QualifierRange = SS.getRange();
John McCalle66edc12009-11-24 19:00:30 +00001953 }
Mike Stump11289f42009-09-09 15:08:12 +00001954
John McCalle66edc12009-11-24 19:00:30 +00001955 return MemberExpr::Create(C, Base, isArrow, Qualifier, QualifierRange,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001956 Member, FoundDecl, MemberNameInfo,
John McCall7decc9e2010-11-18 06:31:45 +00001957 TemplateArgs, Ty, VK, OK);
Douglas Gregorc1905232009-08-26 22:36:53 +00001958}
1959
John McCallfeb624a2010-11-23 20:48:44 +00001960static ExprResult
1961BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
1962 const CXXScopeSpec &SS, FieldDecl *Field,
1963 DeclAccessPair FoundDecl,
1964 const DeclarationNameInfo &MemberNameInfo) {
1965 // x.a is an l-value if 'a' has a reference type. Otherwise:
1966 // x.a is an l-value/x-value/pr-value if the base is (and note
1967 // that *x is always an l-value), except that if the base isn't
1968 // an ordinary object then we must have an rvalue.
1969 ExprValueKind VK = VK_LValue;
1970 ExprObjectKind OK = OK_Ordinary;
1971 if (!IsArrow) {
1972 if (BaseExpr->getObjectKind() == OK_Ordinary)
1973 VK = BaseExpr->getValueKind();
1974 else
1975 VK = VK_RValue;
1976 }
1977 if (VK != VK_RValue && Field->isBitField())
1978 OK = OK_BitField;
1979
1980 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1981 QualType MemberType = Field->getType();
1982 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1983 MemberType = Ref->getPointeeType();
1984 VK = VK_LValue;
1985 } else {
1986 QualType BaseType = BaseExpr->getType();
1987 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1988
1989 Qualifiers BaseQuals = BaseType.getQualifiers();
1990
1991 // GC attributes are never picked up by members.
1992 BaseQuals.removeObjCGCAttr();
1993
1994 // CVR attributes from the base are picked up by members,
1995 // except that 'mutable' members don't pick up 'const'.
1996 if (Field->isMutable()) BaseQuals.removeConst();
1997
1998 Qualifiers MemberQuals
1999 = S.Context.getCanonicalType(MemberType).getQualifiers();
2000
2001 // TR 18037 does not allow fields to be declared with address spaces.
2002 assert(!MemberQuals.hasAddressSpace());
2003
2004 Qualifiers Combined = BaseQuals + MemberQuals;
2005 if (Combined != MemberQuals)
2006 MemberType = S.Context.getQualifiedType(MemberType, Combined);
2007 }
2008
2009 S.MarkDeclarationReferenced(MemberNameInfo.getLoc(), Field);
2010 if (S.PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
2011 FoundDecl, Field))
2012 return ExprError();
2013 return S.Owned(BuildMemberExpr(S.Context, BaseExpr, IsArrow, SS,
2014 Field, FoundDecl, MemberNameInfo,
2015 MemberType, VK, OK));
2016}
2017
John McCall2d74de92009-12-01 22:10:20 +00002018/// Builds an implicit member access expression. The current context
2019/// is known to be an instance method, and the given unqualified lookup
2020/// set is known to contain only instance members, at least one of which
2021/// is from an appropriate type.
John McCalldadc5752010-08-24 06:29:42 +00002022ExprResult
John McCall2d74de92009-12-01 22:10:20 +00002023Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,
2024 LookupResult &R,
2025 const TemplateArgumentListInfo *TemplateArgs,
2026 bool IsKnownInstance) {
John McCalle66edc12009-11-24 19:00:30 +00002027 assert(!R.empty() && !R.isAmbiguous());
2028
John McCalld14a8642009-11-21 08:51:07 +00002029 SourceLocation Loc = R.getNameLoc();
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00002030
Douglas Gregor9ac7a072009-01-07 00:43:41 +00002031 // We may have found a field within an anonymous union or struct
2032 // (C++ [class.union]).
Douglas Gregor6493d9c2009-10-22 07:08:30 +00002033 // FIXME: This needs to happen post-isImplicitMemberReference?
John McCalle66edc12009-11-24 19:00:30 +00002034 // FIXME: template-ids inside anonymous structs?
Francois Pichet783dd6e2010-11-21 06:08:52 +00002035 if (IndirectFieldDecl *FD = R.getAsSingle<IndirectFieldDecl>())
2036 return BuildAnonymousStructUnionMemberReference(Loc, FD);
2037
Sebastian Redlffbcf962009-01-18 18:53:16 +00002038
John McCall2d74de92009-12-01 22:10:20 +00002039 // If this is known to be an instance access, go ahead and build a
2040 // 'this' expression now.
John McCall87fe5d52010-05-20 01:18:31 +00002041 DeclContext *DC = getFunctionLevelDeclContext();
2042 QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
John McCall2d74de92009-12-01 22:10:20 +00002043 Expr *This = 0; // null signifies implicit access
2044 if (IsKnownInstance) {
Douglas Gregorb15af892010-01-07 23:12:05 +00002045 SourceLocation Loc = R.getNameLoc();
2046 if (SS.getRange().isValid())
2047 Loc = SS.getRange().getBegin();
2048 This = new (Context) CXXThisExpr(Loc, ThisType, /*isImplicit=*/true);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00002049 }
2050
John McCallb268a282010-08-23 23:25:46 +00002051 return BuildMemberReferenceExpr(This, ThisType,
John McCall2d74de92009-12-01 22:10:20 +00002052 /*OpLoc*/ SourceLocation(),
2053 /*IsArrow*/ true,
John McCall38836f02010-01-15 08:34:02 +00002054 SS,
2055 /*FirstQualifierInScope*/ 0,
2056 R, TemplateArgs);
John McCalld14a8642009-11-21 08:51:07 +00002057}
2058
John McCalle66edc12009-11-24 19:00:30 +00002059bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
John McCallb53bbd42009-11-22 01:44:31 +00002060 const LookupResult &R,
2061 bool HasTrailingLParen) {
John McCalld14a8642009-11-21 08:51:07 +00002062 // Only when used directly as the postfix-expression of a call.
2063 if (!HasTrailingLParen)
2064 return false;
2065
2066 // Never if a scope specifier was provided.
John McCalle66edc12009-11-24 19:00:30 +00002067 if (SS.isSet())
John McCalld14a8642009-11-21 08:51:07 +00002068 return false;
2069
2070 // Only in C++ or ObjC++.
John McCallb53bbd42009-11-22 01:44:31 +00002071 if (!getLangOptions().CPlusPlus)
John McCalld14a8642009-11-21 08:51:07 +00002072 return false;
2073
2074 // Turn off ADL when we find certain kinds of declarations during
2075 // normal lookup:
2076 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
2077 NamedDecl *D = *I;
2078
2079 // C++0x [basic.lookup.argdep]p3:
2080 // -- a declaration of a class member
2081 // Since using decls preserve this property, we check this on the
2082 // original decl.
John McCall57500772009-12-16 12:17:52 +00002083 if (D->isCXXClassMember())
John McCalld14a8642009-11-21 08:51:07 +00002084 return false;
2085
2086 // C++0x [basic.lookup.argdep]p3:
2087 // -- a block-scope function declaration that is not a
2088 // using-declaration
2089 // NOTE: we also trigger this for function templates (in fact, we
2090 // don't check the decl type at all, since all other decl types
2091 // turn off ADL anyway).
2092 if (isa<UsingShadowDecl>(D))
2093 D = cast<UsingShadowDecl>(D)->getTargetDecl();
2094 else if (D->getDeclContext()->isFunctionOrMethod())
2095 return false;
2096
2097 // C++0x [basic.lookup.argdep]p3:
2098 // -- a declaration that is neither a function or a function
2099 // template
2100 // And also for builtin functions.
2101 if (isa<FunctionDecl>(D)) {
2102 FunctionDecl *FDecl = cast<FunctionDecl>(D);
2103
2104 // But also builtin functions.
2105 if (FDecl->getBuiltinID() && FDecl->isImplicit())
2106 return false;
2107 } else if (!isa<FunctionTemplateDecl>(D))
2108 return false;
2109 }
2110
2111 return true;
2112}
2113
2114
John McCalld14a8642009-11-21 08:51:07 +00002115/// Diagnoses obvious problems with the use of the given declaration
2116/// as an expression. This is only actually called for lookups that
2117/// were not overloaded, and it doesn't promise that the declaration
2118/// will in fact be used.
2119static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) {
2120 if (isa<TypedefDecl>(D)) {
2121 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();
2122 return true;
2123 }
2124
2125 if (isa<ObjCInterfaceDecl>(D)) {
2126 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();
2127 return true;
2128 }
2129
2130 if (isa<NamespaceDecl>(D)) {
2131 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();
2132 return true;
2133 }
2134
2135 return false;
2136}
2137
John McCalldadc5752010-08-24 06:29:42 +00002138ExprResult
John McCalle66edc12009-11-24 19:00:30 +00002139Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
John McCallb53bbd42009-11-22 01:44:31 +00002140 LookupResult &R,
2141 bool NeedsADL) {
John McCall3a60c872009-12-08 22:45:53 +00002142 // If this is a single, fully-resolved result and we don't need ADL,
2143 // just build an ordinary singleton decl ref.
Douglas Gregor4b4844f2010-01-29 17:15:43 +00002144 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>())
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002145 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(),
2146 R.getFoundDecl());
John McCalld14a8642009-11-21 08:51:07 +00002147
2148 // We only need to check the declaration if there's exactly one
2149 // result, because in the overloaded case the results can only be
2150 // functions and function templates.
John McCallb53bbd42009-11-22 01:44:31 +00002151 if (R.isSingleResult() &&
2152 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl()))
John McCalld14a8642009-11-21 08:51:07 +00002153 return ExprError();
2154
John McCall58cc69d2010-01-27 01:50:18 +00002155 // Otherwise, just build an unresolved lookup expression. Suppress
2156 // any lookup-related diagnostics; we'll hash these out later, when
2157 // we've picked a target.
2158 R.suppressDiagnostics();
2159
John McCalld14a8642009-11-21 08:51:07 +00002160 UnresolvedLookupExpr *ULE
Douglas Gregora6e053e2010-12-15 01:34:56 +00002161 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
John McCalle66edc12009-11-24 19:00:30 +00002162 (NestedNameSpecifier*) SS.getScopeRep(),
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002163 SS.getRange(), R.getLookupNameInfo(),
Douglas Gregor30a4f4c2010-05-23 18:57:34 +00002164 NeedsADL, R.isOverloadedResult(),
2165 R.begin(), R.end());
John McCalld14a8642009-11-21 08:51:07 +00002166
2167 return Owned(ULE);
2168}
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002169
John McCall7decc9e2010-11-18 06:31:45 +00002170static ExprValueKind getValueKindForDecl(ASTContext &Context,
2171 const ValueDecl *D) {
John McCall4bc41ae2010-11-18 19:01:18 +00002172 // FIXME: It's not clear to me why NonTypeTemplateParmDecl is a VarDecl.
2173 if (isa<VarDecl>(D) && !isa<NonTypeTemplateParmDecl>(D)) return VK_LValue;
2174 if (isa<FieldDecl>(D)) return VK_LValue;
John McCall7decc9e2010-11-18 06:31:45 +00002175 if (!Context.getLangOptions().CPlusPlus) return VK_RValue;
2176 if (isa<FunctionDecl>(D)) {
2177 if (isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance())
2178 return VK_RValue;
2179 return VK_LValue;
2180 }
2181 return Expr::getValueKindForType(D->getType());
2182}
2183
John McCalld14a8642009-11-21 08:51:07 +00002184
2185/// \brief Complete semantic analysis for a reference to the given declaration.
John McCalldadc5752010-08-24 06:29:42 +00002186ExprResult
John McCalle66edc12009-11-24 19:00:30 +00002187Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002188 const DeclarationNameInfo &NameInfo,
2189 NamedDecl *D) {
John McCalld14a8642009-11-21 08:51:07 +00002190 assert(D && "Cannot refer to a NULL declaration");
John McCall283b9012009-11-22 00:44:51 +00002191 assert(!isa<FunctionTemplateDecl>(D) &&
2192 "Cannot refer unambiguously to a function template");
John McCalld14a8642009-11-21 08:51:07 +00002193
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002194 SourceLocation Loc = NameInfo.getLoc();
John McCalld14a8642009-11-21 08:51:07 +00002195 if (CheckDeclInExpr(*this, Loc, D))
2196 return ExprError();
Steve Narofff1e53692007-03-23 22:27:02 +00002197
Douglas Gregore7488b92009-12-01 16:58:18 +00002198 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
2199 // Specifically diagnose references to class templates that are missing
2200 // a template argument list.
2201 Diag(Loc, diag::err_template_decl_ref)
2202 << Template << SS.getRange();
2203 Diag(Template->getLocation(), diag::note_template_decl_here);
2204 return ExprError();
2205 }
2206
2207 // Make sure that we're referring to a value.
2208 ValueDecl *VD = dyn_cast<ValueDecl>(D);
2209 if (!VD) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002210 Diag(Loc, diag::err_ref_non_value)
Douglas Gregore7488b92009-12-01 16:58:18 +00002211 << D << SS.getRange();
John McCallb48971d2009-12-18 18:35:10 +00002212 Diag(D->getLocation(), diag::note_declared_at);
Douglas Gregore7488b92009-12-01 16:58:18 +00002213 return ExprError();
2214 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002215
Douglas Gregor171c45a2009-02-18 21:56:37 +00002216 // Check whether this declaration can be used. Note that we suppress
2217 // this check when we're going to perform argument-dependent lookup
2218 // on this function name, because this might not be the function
2219 // that overload resolution actually selects.
John McCalld14a8642009-11-21 08:51:07 +00002220 if (DiagnoseUseOfDecl(VD, Loc))
Douglas Gregor171c45a2009-02-18 21:56:37 +00002221 return ExprError();
2222
Steve Naroff8de9c3a2008-09-05 22:11:13 +00002223 // Only create DeclRefExpr's for valid Decl's.
2224 if (VD->isInvalidDecl())
Sebastian Redlffbcf962009-01-18 18:53:16 +00002225 return ExprError();
2226
Francois Pichet783dd6e2010-11-21 06:08:52 +00002227 // Handle anonymous.
2228 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(VD))
2229 return BuildAnonymousStructUnionMemberReference(Loc, FD);
2230
John McCall7decc9e2010-11-18 06:31:45 +00002231 ExprValueKind VK = getValueKindForDecl(Context, VD);
2232
Chris Lattner2a9d9892008-10-20 05:16:36 +00002233 // If the identifier reference is inside a block, and it refers to a value
2234 // that is outside the block, create a BlockDeclRefExpr instead of a
2235 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when
2236 // the block is formed.
Steve Naroff8de9c3a2008-09-05 22:11:13 +00002237 //
Chris Lattner2a9d9892008-10-20 05:16:36 +00002238 // We do not do this for things like enum constants, global variables, etc,
2239 // as they do not get snapshotted.
2240 //
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002241 if (getCurBlock() &&
Douglas Gregor9a28e842010-03-01 23:15:13 +00002242 ShouldSnapshotBlockValueReference(*this, getCurBlock(), VD)) {
Mike Stump7dafa0d2010-01-05 02:56:35 +00002243 if (VD->getType().getTypePtr()->isVariablyModifiedType()) {
2244 Diag(Loc, diag::err_ref_vm_type);
2245 Diag(D->getLocation(), diag::note_declared_at);
2246 return ExprError();
2247 }
2248
Fariborz Jahanianfa24e102010-03-16 23:39:51 +00002249 if (VD->getType()->isArrayType()) {
Mike Stump8971a862010-01-05 03:10:36 +00002250 Diag(Loc, diag::err_ref_array_type);
2251 Diag(D->getLocation(), diag::note_declared_at);
2252 return ExprError();
2253 }
2254
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00002255 MarkDeclarationReferenced(Loc, VD);
Eli Friedman7fa3faa2009-03-22 23:00:19 +00002256 QualType ExprTy = VD->getType().getNonReferenceType();
John McCall7decc9e2010-11-18 06:31:45 +00002257
Steve Naroff1d95e5a2008-10-10 01:28:17 +00002258 // The BlocksAttr indicates the variable is bound by-reference.
Fariborz Jahaniana3e54bd2010-11-16 19:29:39 +00002259 bool byrefVar = (VD->getAttr<BlocksAttr>() != 0);
Fariborz Jahanian70c0b082010-07-12 17:26:57 +00002260 QualType T = VD->getType();
Fariborz Jahaniana3e54bd2010-11-16 19:29:39 +00002261 BlockDeclRefExpr *BDRE;
2262
2263 if (!byrefVar) {
2264 // This is to record that a 'const' was actually synthesize and added.
2265 bool constAdded = !ExprTy.isConstQualified();
2266 // Variable will be bound by-copy, make it const within the closure.
2267 ExprTy.addConst();
John McCall7decc9e2010-11-18 06:31:45 +00002268 BDRE = new (Context) BlockDeclRefExpr(VD, ExprTy, VK,
2269 Loc, false, constAdded);
Fariborz Jahaniana3e54bd2010-11-16 19:29:39 +00002270 }
2271 else
John McCall7decc9e2010-11-18 06:31:45 +00002272 BDRE = new (Context) BlockDeclRefExpr(VD, ExprTy, VK, Loc, true);
Fariborz Jahaniana3e54bd2010-11-16 19:29:39 +00002273
Fariborz Jahanian4239aa12010-07-09 22:21:32 +00002274 if (getLangOptions().CPlusPlus) {
2275 if (!T->isDependentType() && !T->isReferenceType()) {
2276 Expr *E = new (Context)
2277 DeclRefExpr(const_cast<ValueDecl*>(BDRE->getDecl()), T,
John McCall7decc9e2010-11-18 06:31:45 +00002278 VK, SourceLocation());
Fariborz Jahanian2a5deb52010-11-11 00:11:38 +00002279 if (T->getAs<RecordType>())
2280 if (!T->isUnionType()) {
2281 ExprResult Res = PerformCopyInitialization(
Fariborz Jahanian4239aa12010-07-09 22:21:32 +00002282 InitializedEntity::InitializeBlock(VD->getLocation(),
Fariborz Jahanian28ed9272010-06-07 16:14:00 +00002283 T, false),
Fariborz Jahanian4239aa12010-07-09 22:21:32 +00002284 SourceLocation(),
2285 Owned(E));
Fariborz Jahanian2a5deb52010-11-11 00:11:38 +00002286 if (!Res.isInvalid()) {
Douglas Gregora40433a2010-12-07 00:41:46 +00002287 Res = MaybeCreateExprWithCleanups(Res);
Fariborz Jahanian2a5deb52010-11-11 00:11:38 +00002288 Expr *Init = Res.takeAs<Expr>();
2289 BDRE->setCopyConstructorExpr(Init);
2290 }
Fariborz Jahanian4239aa12010-07-09 22:21:32 +00002291 }
Fariborz Jahanianea882cd2010-06-04 21:35:44 +00002292 }
2293 }
2294 return Owned(BDRE);
Steve Naroff1d95e5a2008-10-10 01:28:17 +00002295 }
2296 // If this reference is not in a block or if the referenced variable is
2297 // within the block, create a normal DeclRefExpr.
Douglas Gregor4619e432008-12-05 23:32:09 +00002298
John McCall7decc9e2010-11-18 06:31:45 +00002299 return BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), VK,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002300 NameInfo, &SS);
Chris Lattner17ed4872006-11-20 04:58:19 +00002301}
Chris Lattnere168f762006-11-10 05:29:30 +00002302
John McCalldadc5752010-08-24 06:29:42 +00002303ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
Sebastian Redlffbcf962009-01-18 18:53:16 +00002304 tok::TokenKind Kind) {
Chris Lattner6307f192008-08-10 01:53:14 +00002305 PredefinedExpr::IdentType IT;
Sebastian Redlffbcf962009-01-18 18:53:16 +00002306
Chris Lattnere168f762006-11-10 05:29:30 +00002307 switch (Kind) {
Chris Lattner317e6ba2008-01-12 18:39:25 +00002308 default: assert(0 && "Unknown simple primary expr!");
Chris Lattner6307f192008-08-10 01:53:14 +00002309 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
2310 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
2311 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
Chris Lattnere168f762006-11-10 05:29:30 +00002312 }
Chris Lattner317e6ba2008-01-12 18:39:25 +00002313
Chris Lattnera81a0272008-01-12 08:14:25 +00002314 // Pre-defined identifiers are of type char[x], where x is the length of the
2315 // string.
Mike Stump11289f42009-09-09 15:08:12 +00002316
Anders Carlsson2fb08242009-09-08 18:24:21 +00002317 Decl *currentDecl = getCurFunctionOrMethodDecl();
Fariborz Jahanian94627442010-07-23 21:53:24 +00002318 if (!currentDecl && getCurBlock())
2319 currentDecl = getCurBlock()->TheDecl;
Anders Carlsson2fb08242009-09-08 18:24:21 +00002320 if (!currentDecl) {
Chris Lattnerf45c5ec2008-12-12 05:05:20 +00002321 Diag(Loc, diag::ext_predef_outside_function);
Anders Carlsson2fb08242009-09-08 18:24:21 +00002322 currentDecl = Context.getTranslationUnitDecl();
Chris Lattnerf45c5ec2008-12-12 05:05:20 +00002323 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002324
Anders Carlsson0b209a82009-09-11 01:22:35 +00002325 QualType ResTy;
2326 if (cast<DeclContext>(currentDecl)->isDependentContext()) {
2327 ResTy = Context.DependentTy;
2328 } else {
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002329 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002330
Anders Carlsson0b209a82009-09-11 01:22:35 +00002331 llvm::APInt LengthI(32, Length + 1);
John McCall8ccfcb52009-09-24 19:53:00 +00002332 ResTy = Context.CharTy.withConst();
Anders Carlsson0b209a82009-09-11 01:22:35 +00002333 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
2334 }
Steve Narofff6009ed2009-01-21 00:14:39 +00002335 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
Chris Lattnere168f762006-11-10 05:29:30 +00002336}
2337
John McCalldadc5752010-08-24 06:29:42 +00002338ExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
Chris Lattner23b7eb62007-06-15 23:05:46 +00002339 llvm::SmallString<16> CharBuffer;
Douglas Gregordc970f02010-03-16 22:30:13 +00002340 bool Invalid = false;
2341 llvm::StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
2342 if (Invalid)
2343 return ExprError();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002344
Benjamin Kramer0a1abd42010-02-27 13:44:12 +00002345 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(),
2346 PP);
Steve Naroffae4143e2007-04-26 20:39:23 +00002347 if (Literal.hadError())
Sebastian Redlffbcf962009-01-18 18:53:16 +00002348 return ExprError();
Chris Lattneref24b382008-03-01 08:32:21 +00002349
Chris Lattnerc3847ba2009-12-30 21:19:39 +00002350 QualType Ty;
2351 if (!getLangOptions().CPlusPlus)
2352 Ty = Context.IntTy; // 'x' and L'x' -> int in C.
2353 else if (Literal.isWide())
2354 Ty = Context.WCharTy; // L'x' -> wchar_t in C++.
Eli Friedmaneb1df702010-02-03 18:21:45 +00002355 else if (Literal.isMultiChar())
2356 Ty = Context.IntTy; // 'wxyz' -> int in C++.
Chris Lattnerc3847ba2009-12-30 21:19:39 +00002357 else
2358 Ty = Context.CharTy; // 'x' -> char in C++
Chris Lattneref24b382008-03-01 08:32:21 +00002359
Sebastian Redl20614a72009-01-20 22:23:13 +00002360 return Owned(new (Context) CharacterLiteral(Literal.getValue(),
2361 Literal.isWide(),
Chris Lattnerc3847ba2009-12-30 21:19:39 +00002362 Ty, Tok.getLocation()));
Steve Naroffae4143e2007-04-26 20:39:23 +00002363}
2364
John McCalldadc5752010-08-24 06:29:42 +00002365ExprResult Sema::ActOnNumericConstant(const Token &Tok) {
Sebastian Redlffbcf962009-01-18 18:53:16 +00002366 // Fast path for a single digit (which is quite common). A single digit
Steve Narofff2fb89e2007-03-13 20:29:44 +00002367 // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
2368 if (Tok.getLength() == 1) {
Chris Lattner9240b3e2009-01-26 22:36:52 +00002369 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
Chris Lattnerc4c18192009-01-16 07:10:29 +00002370 unsigned IntSize = Context.Target.getIntWidth();
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00002371 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val-'0'),
Steve Naroff5faaef72009-01-20 19:53:53 +00002372 Context.IntTy, Tok.getLocation()));
Steve Narofff2fb89e2007-03-13 20:29:44 +00002373 }
Ted Kremeneke9814182009-01-13 23:19:12 +00002374
Chris Lattner23b7eb62007-06-15 23:05:46 +00002375 llvm::SmallString<512> IntegerBuffer;
Chris Lattnera1cf5f92008-09-30 20:53:45 +00002376 // Add padding so that NumericLiteralParser can overread by one character.
2377 IntegerBuffer.resize(Tok.getLength()+1);
Steve Naroff8160ea22007-03-06 01:09:46 +00002378 const char *ThisTokBegin = &IntegerBuffer[0];
Sebastian Redlffbcf962009-01-18 18:53:16 +00002379
Chris Lattner67ca9252007-05-21 01:08:44 +00002380 // Get the spelling of the token, which eliminates trigraphs, etc.
Douglas Gregordc970f02010-03-16 22:30:13 +00002381 bool Invalid = false;
2382 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
2383 if (Invalid)
2384 return ExprError();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002385
Mike Stump11289f42009-09-09 15:08:12 +00002386 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
Steve Naroff451d8f162007-03-12 23:22:38 +00002387 Tok.getLocation(), PP);
Steve Narofff2fb89e2007-03-13 20:29:44 +00002388 if (Literal.hadError)
Sebastian Redlffbcf962009-01-18 18:53:16 +00002389 return ExprError();
2390
Chris Lattner1c20a172007-08-26 03:42:43 +00002391 Expr *Res;
Sebastian Redlffbcf962009-01-18 18:53:16 +00002392
Chris Lattner1c20a172007-08-26 03:42:43 +00002393 if (Literal.isFloatingLiteral()) {
Chris Lattnerec0a6d92007-09-22 18:29:59 +00002394 QualType Ty;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00002395 if (Literal.isFloat)
Chris Lattnerec0a6d92007-09-22 18:29:59 +00002396 Ty = Context.FloatTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00002397 else if (!Literal.isLong)
Chris Lattnerec0a6d92007-09-22 18:29:59 +00002398 Ty = Context.DoubleTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00002399 else
Chris Lattner7570e9c2008-03-08 08:52:55 +00002400 Ty = Context.LongDoubleTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00002401
2402 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
2403
John McCall53b93a02009-12-24 09:08:04 +00002404 using llvm::APFloat;
2405 APFloat Val(Format);
2406
2407 APFloat::opStatus result = Literal.GetFloatValue(Val);
John McCall122c8312009-12-24 11:09:08 +00002408
2409 // Overflow is always an error, but underflow is only an error if
2410 // we underflowed to zero (APFloat reports denormals as underflow).
2411 if ((result & APFloat::opOverflow) ||
2412 ((result & APFloat::opUnderflow) && Val.isZero())) {
John McCall53b93a02009-12-24 09:08:04 +00002413 unsigned diagnostic;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002414 llvm::SmallString<20> buffer;
John McCall53b93a02009-12-24 09:08:04 +00002415 if (result & APFloat::opOverflow) {
John McCall62abc942010-02-26 23:35:57 +00002416 diagnostic = diag::warn_float_overflow;
John McCall53b93a02009-12-24 09:08:04 +00002417 APFloat::getLargest(Format).toString(buffer);
2418 } else {
John McCall62abc942010-02-26 23:35:57 +00002419 diagnostic = diag::warn_float_underflow;
John McCall53b93a02009-12-24 09:08:04 +00002420 APFloat::getSmallest(Format).toString(buffer);
2421 }
2422
2423 Diag(Tok.getLocation(), diagnostic)
2424 << Ty
2425 << llvm::StringRef(buffer.data(), buffer.size());
2426 }
2427
2428 bool isExact = (result == APFloat::opOK);
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00002429 Res = FloatingLiteral::Create(Context, Val, isExact, Ty, Tok.getLocation());
Sebastian Redlffbcf962009-01-18 18:53:16 +00002430
Peter Collingbourne0b69e1a2010-12-04 01:50:56 +00002431 if (getLangOptions().SinglePrecisionConstants && Ty == Context.DoubleTy)
2432 ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast);
2433
Chris Lattner1c20a172007-08-26 03:42:43 +00002434 } else if (!Literal.isIntegerLiteral()) {
Sebastian Redlffbcf962009-01-18 18:53:16 +00002435 return ExprError();
Chris Lattner1c20a172007-08-26 03:42:43 +00002436 } else {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002437 QualType Ty;
Chris Lattner67ca9252007-05-21 01:08:44 +00002438
Neil Boothac582c52007-08-29 22:00:19 +00002439 // long long is a C99 feature.
2440 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
Neil Booth4a1ee052007-08-29 22:13:52 +00002441 Literal.isLongLong)
Neil Boothac582c52007-08-29 22:00:19 +00002442 Diag(Tok.getLocation(), diag::ext_longlong);
2443
Chris Lattner67ca9252007-05-21 01:08:44 +00002444 // Get the value in the widest-possible width.
Chris Lattner37e05872008-03-05 18:54:05 +00002445 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
Sebastian Redlffbcf962009-01-18 18:53:16 +00002446
Chris Lattner67ca9252007-05-21 01:08:44 +00002447 if (Literal.GetIntegerValue(ResultVal)) {
2448 // If this value didn't fit into uintmax_t, warn and force to ull.
2449 Diag(Tok.getLocation(), diag::warn_integer_too_large);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002450 Ty = Context.UnsignedLongLongTy;
2451 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
Chris Lattner37e05872008-03-05 18:54:05 +00002452 "long long is not intmax_t?");
Steve Naroff09ef4742007-03-09 23:16:33 +00002453 } else {
Chris Lattner67ca9252007-05-21 01:08:44 +00002454 // If this value fits into a ULL, try to figure out what else it fits into
2455 // according to the rules of C99 6.4.4.1p5.
Sebastian Redlffbcf962009-01-18 18:53:16 +00002456
Chris Lattner67ca9252007-05-21 01:08:44 +00002457 // Octal, Hexadecimal, and integers with a U suffix are allowed to
2458 // be an unsigned int.
2459 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
2460
2461 // Check from smallest to largest, picking the smallest type we can.
Chris Lattner55258cf2008-05-09 05:59:00 +00002462 unsigned Width = 0;
Chris Lattner7b939cf2007-08-23 21:58:08 +00002463 if (!Literal.isLong && !Literal.isLongLong) {
2464 // Are int/unsigned possibilities?
Chris Lattner55258cf2008-05-09 05:59:00 +00002465 unsigned IntSize = Context.Target.getIntWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002466
Chris Lattner67ca9252007-05-21 01:08:44 +00002467 // Does it fit in a unsigned int?
2468 if (ResultVal.isIntN(IntSize)) {
2469 // Does it fit in a signed int?
2470 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002471 Ty = Context.IntTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00002472 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002473 Ty = Context.UnsignedIntTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00002474 Width = IntSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00002475 }
Chris Lattner67ca9252007-05-21 01:08:44 +00002476 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002477
Chris Lattner67ca9252007-05-21 01:08:44 +00002478 // Are long/unsigned long possibilities?
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002479 if (Ty.isNull() && !Literal.isLongLong) {
Chris Lattner55258cf2008-05-09 05:59:00 +00002480 unsigned LongSize = Context.Target.getLongWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002481
Chris Lattner67ca9252007-05-21 01:08:44 +00002482 // Does it fit in a unsigned long?
2483 if (ResultVal.isIntN(LongSize)) {
2484 // Does it fit in a signed long?
2485 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002486 Ty = Context.LongTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00002487 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002488 Ty = Context.UnsignedLongTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00002489 Width = LongSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00002490 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002491 }
2492
Chris Lattner67ca9252007-05-21 01:08:44 +00002493 // Finally, check long long if needed.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002494 if (Ty.isNull()) {
Chris Lattner55258cf2008-05-09 05:59:00 +00002495 unsigned LongLongSize = Context.Target.getLongLongWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002496
Chris Lattner67ca9252007-05-21 01:08:44 +00002497 // Does it fit in a unsigned long long?
2498 if (ResultVal.isIntN(LongLongSize)) {
2499 // Does it fit in a signed long long?
2500 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002501 Ty = Context.LongLongTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00002502 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002503 Ty = Context.UnsignedLongLongTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00002504 Width = LongLongSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00002505 }
2506 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002507
Chris Lattner67ca9252007-05-21 01:08:44 +00002508 // If we still couldn't decide a type, we probably have something that
2509 // does not fit in a signed long long, but has no U suffix.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002510 if (Ty.isNull()) {
Chris Lattner67ca9252007-05-21 01:08:44 +00002511 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002512 Ty = Context.UnsignedLongLongTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00002513 Width = Context.Target.getLongLongWidth();
Chris Lattner67ca9252007-05-21 01:08:44 +00002514 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002515
Chris Lattner55258cf2008-05-09 05:59:00 +00002516 if (ResultVal.getBitWidth() != Width)
Jay Foad6d4db0c2010-12-07 08:25:34 +00002517 ResultVal = ResultVal.trunc(Width);
Steve Naroff09ef4742007-03-09 23:16:33 +00002518 }
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00002519 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());
Steve Naroff09ef4742007-03-09 23:16:33 +00002520 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002521
Chris Lattner1c20a172007-08-26 03:42:43 +00002522 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
2523 if (Literal.isImaginary)
Mike Stump11289f42009-09-09 15:08:12 +00002524 Res = new (Context) ImaginaryLiteral(Res,
Steve Narofff6009ed2009-01-21 00:14:39 +00002525 Context.getComplexType(Res->getType()));
Sebastian Redlffbcf962009-01-18 18:53:16 +00002526
2527 return Owned(Res);
Chris Lattnere168f762006-11-10 05:29:30 +00002528}
2529
John McCalldadc5752010-08-24 06:29:42 +00002530ExprResult Sema::ActOnParenExpr(SourceLocation L,
John McCallb268a282010-08-23 23:25:46 +00002531 SourceLocation R, Expr *E) {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00002532 assert((E != 0) && "ActOnParenExpr() missing expr");
Steve Narofff6009ed2009-01-21 00:14:39 +00002533 return Owned(new (Context) ParenExpr(L, R, E));
Chris Lattnere168f762006-11-10 05:29:30 +00002534}
2535
Steve Naroff71b59a92007-06-04 22:22:31 +00002536/// The UsualUnaryConversions() function is *not* called by this routine.
Steve Naroffa78fe7e2007-05-16 19:47:19 +00002537/// See C99 6.3.2.1p[2-4] for more details.
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002538bool Sema::CheckSizeOfAlignOfOperand(QualType exprType,
Sebastian Redl6f282892008-11-11 17:56:53 +00002539 SourceLocation OpLoc,
John McCall36e7fe32010-10-12 00:20:44 +00002540 SourceRange ExprRange,
Sebastian Redl6f282892008-11-11 17:56:53 +00002541 bool isSizeof) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002542 if (exprType->isDependentType())
2543 return false;
2544
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00002545 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
2546 // the result is the size of the referenced type."
2547 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the
2548 // result shall be the alignment of the referenced type."
2549 if (const ReferenceType *Ref = exprType->getAs<ReferenceType>())
2550 exprType = Ref->getPointeeType();
2551
Steve Naroff043d45d2007-05-15 02:32:35 +00002552 // C99 6.5.3.4p1:
John McCall4c98fd82009-11-04 07:28:41 +00002553 if (exprType->isFunctionType()) {
Chris Lattner62975a72009-04-24 00:30:45 +00002554 // alignof(function) is allowed as an extension.
Chris Lattnerb1355b12009-01-24 19:46:37 +00002555 if (isSizeof)
2556 Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange;
2557 return false;
2558 }
Mike Stump11289f42009-09-09 15:08:12 +00002559
Chris Lattner62975a72009-04-24 00:30:45 +00002560 // Allow sizeof(void)/alignof(void) as an extension.
Chris Lattnerb1355b12009-01-24 19:46:37 +00002561 if (exprType->isVoidType()) {
Chris Lattner3b054132008-11-19 05:08:23 +00002562 Diag(OpLoc, diag::ext_sizeof_void_type)
2563 << (isSizeof ? "sizeof" : "__alignof") << ExprRange;
Chris Lattnerb1355b12009-01-24 19:46:37 +00002564 return false;
2565 }
Mike Stump11289f42009-09-09 15:08:12 +00002566
Chris Lattner62975a72009-04-24 00:30:45 +00002567 if (RequireCompleteType(OpLoc, exprType,
Douglas Gregor906db8a2009-12-15 16:44:32 +00002568 PDiag(diag::err_sizeof_alignof_incomplete_type)
2569 << int(!isSizeof) << ExprRange))
Chris Lattner62975a72009-04-24 00:30:45 +00002570 return true;
Mike Stump11289f42009-09-09 15:08:12 +00002571
Chris Lattner62975a72009-04-24 00:30:45 +00002572 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode.
John McCall8b07ec22010-05-15 11:32:37 +00002573 if (LangOpts.ObjCNonFragileABI && exprType->isObjCObjectType()) {
Chris Lattner62975a72009-04-24 00:30:45 +00002574 Diag(OpLoc, diag::err_sizeof_nonfragile_interface)
Chris Lattnercd2a8c52009-04-24 22:30:50 +00002575 << exprType << isSizeof << ExprRange;
2576 return true;
Chris Lattner37920f52009-04-21 19:55:16 +00002577 }
Mike Stump11289f42009-09-09 15:08:12 +00002578
Chris Lattner62975a72009-04-24 00:30:45 +00002579 return false;
Steve Naroff043d45d2007-05-15 02:32:35 +00002580}
2581
John McCall36e7fe32010-10-12 00:20:44 +00002582static bool CheckAlignOfExpr(Sema &S, Expr *E, SourceLocation OpLoc,
2583 SourceRange ExprRange) {
Chris Lattner8dff0172009-01-24 20:17:12 +00002584 E = E->IgnoreParens();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002585
Mike Stump11289f42009-09-09 15:08:12 +00002586 // alignof decl is always ok.
Chris Lattner8dff0172009-01-24 20:17:12 +00002587 if (isa<DeclRefExpr>(E))
2588 return false;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002589
2590 // Cannot know anything else if the expression is dependent.
2591 if (E->isTypeDependent())
2592 return false;
2593
Douglas Gregor71235ec2009-05-02 02:18:30 +00002594 if (E->getBitField()) {
John McCall36e7fe32010-10-12 00:20:44 +00002595 S. Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange;
Douglas Gregor71235ec2009-05-02 02:18:30 +00002596 return true;
Chris Lattner8dff0172009-01-24 20:17:12 +00002597 }
Douglas Gregor71235ec2009-05-02 02:18:30 +00002598
2599 // Alignment of a field access is always okay, so long as it isn't a
2600 // bit-field.
2601 if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
Mike Stump212005c2009-07-22 18:58:19 +00002602 if (isa<FieldDecl>(ME->getMemberDecl()))
Douglas Gregor71235ec2009-05-02 02:18:30 +00002603 return false;
2604
John McCall36e7fe32010-10-12 00:20:44 +00002605 return S.CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false);
Chris Lattner8dff0172009-01-24 20:17:12 +00002606}
2607
Douglas Gregor0950e412009-03-13 21:01:28 +00002608/// \brief Build a sizeof or alignof expression given a type operand.
John McCalldadc5752010-08-24 06:29:42 +00002609ExprResult
John McCallbcd03502009-12-07 02:54:59 +00002610Sema::CreateSizeOfAlignOfExpr(TypeSourceInfo *TInfo,
John McCall4c98fd82009-11-04 07:28:41 +00002611 SourceLocation OpLoc,
Douglas Gregor0950e412009-03-13 21:01:28 +00002612 bool isSizeOf, SourceRange R) {
John McCallbcd03502009-12-07 02:54:59 +00002613 if (!TInfo)
Douglas Gregor0950e412009-03-13 21:01:28 +00002614 return ExprError();
2615
John McCallbcd03502009-12-07 02:54:59 +00002616 QualType T = TInfo->getType();
John McCall4c98fd82009-11-04 07:28:41 +00002617
Douglas Gregor0950e412009-03-13 21:01:28 +00002618 if (!T->isDependentType() &&
2619 CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf))
2620 return ExprError();
2621
2622 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
John McCallbcd03502009-12-07 02:54:59 +00002623 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, TInfo,
Douglas Gregor0950e412009-03-13 21:01:28 +00002624 Context.getSizeType(), OpLoc,
2625 R.getEnd()));
2626}
2627
2628/// \brief Build a sizeof or alignof expression given an expression
2629/// operand.
John McCalldadc5752010-08-24 06:29:42 +00002630ExprResult
Mike Stump11289f42009-09-09 15:08:12 +00002631Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
Douglas Gregor0950e412009-03-13 21:01:28 +00002632 bool isSizeOf, SourceRange R) {
2633 // Verify that the operand is valid.
2634 bool isInvalid = false;
2635 if (E->isTypeDependent()) {
2636 // Delay type-checking for type-dependent expressions.
2637 } else if (!isSizeOf) {
John McCall36e7fe32010-10-12 00:20:44 +00002638 isInvalid = CheckAlignOfExpr(*this, E, OpLoc, R);
Douglas Gregor71235ec2009-05-02 02:18:30 +00002639 } else if (E->getBitField()) { // C99 6.5.3.4p1.
Douglas Gregor0950e412009-03-13 21:01:28 +00002640 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0;
2641 isInvalid = true;
John McCall36226622010-10-12 02:09:17 +00002642 } else if (E->getType()->isPlaceholderType()) {
2643 ExprResult PE = CheckPlaceholderExpr(E, OpLoc);
2644 if (PE.isInvalid()) return ExprError();
2645 return CreateSizeOfAlignOfExpr(PE.take(), OpLoc, isSizeOf, R);
Douglas Gregor0950e412009-03-13 21:01:28 +00002646 } else {
2647 isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true);
2648 }
2649
2650 if (isInvalid)
2651 return ExprError();
2652
2653 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
2654 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E,
2655 Context.getSizeType(), OpLoc,
2656 R.getEnd()));
2657}
2658
Sebastian Redl6f282892008-11-11 17:56:53 +00002659/// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and
2660/// the same for @c alignof and @c __alignof
2661/// Note that the ArgRange is invalid if isType is false.
John McCalldadc5752010-08-24 06:29:42 +00002662ExprResult
Sebastian Redl6f282892008-11-11 17:56:53 +00002663Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
2664 void *TyOrEx, const SourceRange &ArgRange) {
Chris Lattner0d8b1a12006-11-20 04:34:45 +00002665 // If error parsing type, ignore.
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002666 if (TyOrEx == 0) return ExprError();
Steve Naroff043d45d2007-05-15 02:32:35 +00002667
Sebastian Redl6f282892008-11-11 17:56:53 +00002668 if (isType) {
John McCallbcd03502009-12-07 02:54:59 +00002669 TypeSourceInfo *TInfo;
John McCallba7bf592010-08-24 05:47:05 +00002670 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
John McCallbcd03502009-12-07 02:54:59 +00002671 return CreateSizeOfAlignOfExpr(TInfo, OpLoc, isSizeof, ArgRange);
Mike Stump11289f42009-09-09 15:08:12 +00002672 }
Sebastian Redl6f282892008-11-11 17:56:53 +00002673
Douglas Gregor0950e412009-03-13 21:01:28 +00002674 Expr *ArgEx = (Expr *)TyOrEx;
John McCalldadc5752010-08-24 06:29:42 +00002675 ExprResult Result
Douglas Gregor0950e412009-03-13 21:01:28 +00002676 = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange());
2677
Douglas Gregor0950e412009-03-13 21:01:28 +00002678 return move(Result);
Chris Lattnere168f762006-11-10 05:29:30 +00002679}
2680
John McCall4bc41ae2010-11-18 19:01:18 +00002681static QualType CheckRealImagOperand(Sema &S, Expr *&V, SourceLocation Loc,
2682 bool isReal) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002683 if (V->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00002684 return S.Context.DependentTy;
Mike Stump11289f42009-09-09 15:08:12 +00002685
John McCall34376a62010-12-04 03:47:34 +00002686 // _Real and _Imag are only l-values for normal l-values.
2687 if (V->getObjectKind() != OK_Ordinary)
John McCall27584242010-12-06 20:48:59 +00002688 S.DefaultLvalueConversion(V);
John McCall34376a62010-12-04 03:47:34 +00002689
Chris Lattnere267f5d2007-08-26 05:39:26 +00002690 // These operators return the element type of a complex type.
John McCall9dd450b2009-09-21 23:43:11 +00002691 if (const ComplexType *CT = V->getType()->getAs<ComplexType>())
Chris Lattner30b5dd02007-08-24 21:16:53 +00002692 return CT->getElementType();
Mike Stump11289f42009-09-09 15:08:12 +00002693
Chris Lattnere267f5d2007-08-26 05:39:26 +00002694 // Otherwise they pass through real integer and floating point types here.
2695 if (V->getType()->isArithmeticType())
2696 return V->getType();
Mike Stump11289f42009-09-09 15:08:12 +00002697
John McCall36226622010-10-12 02:09:17 +00002698 // Test for placeholders.
John McCall4bc41ae2010-11-18 19:01:18 +00002699 ExprResult PR = S.CheckPlaceholderExpr(V, Loc);
John McCall36226622010-10-12 02:09:17 +00002700 if (PR.isInvalid()) return QualType();
2701 if (PR.take() != V) {
2702 V = PR.take();
John McCall4bc41ae2010-11-18 19:01:18 +00002703 return CheckRealImagOperand(S, V, Loc, isReal);
John McCall36226622010-10-12 02:09:17 +00002704 }
2705
Chris Lattnere267f5d2007-08-26 05:39:26 +00002706 // Reject anything else.
John McCall4bc41ae2010-11-18 19:01:18 +00002707 S.Diag(Loc, diag::err_realimag_invalid_type) << V->getType()
Chris Lattner709322b2009-02-17 08:12:06 +00002708 << (isReal ? "__real" : "__imag");
Chris Lattnere267f5d2007-08-26 05:39:26 +00002709 return QualType();
Chris Lattner30b5dd02007-08-24 21:16:53 +00002710}
2711
2712
Chris Lattnere168f762006-11-10 05:29:30 +00002713
John McCalldadc5752010-08-24 06:29:42 +00002714ExprResult
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002715Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
John McCallb268a282010-08-23 23:25:46 +00002716 tok::TokenKind Kind, Expr *Input) {
John McCalle3027922010-08-25 11:45:40 +00002717 UnaryOperatorKind Opc;
Chris Lattnere168f762006-11-10 05:29:30 +00002718 switch (Kind) {
2719 default: assert(0 && "Unknown unary op!");
John McCalle3027922010-08-25 11:45:40 +00002720 case tok::plusplus: Opc = UO_PostInc; break;
2721 case tok::minusminus: Opc = UO_PostDec; break;
Chris Lattnere168f762006-11-10 05:29:30 +00002722 }
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002723
John McCallb268a282010-08-23 23:25:46 +00002724 return BuildUnaryOp(S, OpLoc, Opc, Input);
Chris Lattnere168f762006-11-10 05:29:30 +00002725}
2726
John McCall4bc41ae2010-11-18 19:01:18 +00002727/// Expressions of certain arbitrary types are forbidden by C from
2728/// having l-value type. These are:
2729/// - 'void', but not qualified void
2730/// - function types
2731///
2732/// The exact rule here is C99 6.3.2.1:
2733/// An lvalue is an expression with an object type or an incomplete
2734/// type other than void.
2735static bool IsCForbiddenLValueType(ASTContext &C, QualType T) {
2736 return ((T->isVoidType() && !T.hasQualifiers()) ||
2737 T->isFunctionType());
2738}
2739
John McCalldadc5752010-08-24 06:29:42 +00002740ExprResult
John McCallb268a282010-08-23 23:25:46 +00002741Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
2742 Expr *Idx, SourceLocation RLoc) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00002743 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCalldadc5752010-08-24 06:29:42 +00002744 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
John McCallb268a282010-08-23 23:25:46 +00002745 if (Result.isInvalid()) return ExprError();
2746 Base = Result.take();
Nate Begeman5ec4b312009-08-10 23:49:36 +00002747
John McCallb268a282010-08-23 23:25:46 +00002748 Expr *LHSExp = Base, *RHSExp = Idx;
Mike Stump11289f42009-09-09 15:08:12 +00002749
Douglas Gregor40412ac2008-11-19 17:17:41 +00002750 if (getLangOptions().CPlusPlus &&
Douglas Gregor7a77a6b2009-05-19 00:01:19 +00002751 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) {
Douglas Gregor7a77a6b2009-05-19 00:01:19 +00002752 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
John McCall7decc9e2010-11-18 06:31:45 +00002753 Context.DependentTy,
2754 VK_LValue, OK_Ordinary,
2755 RLoc));
Douglas Gregor7a77a6b2009-05-19 00:01:19 +00002756 }
2757
Mike Stump11289f42009-09-09 15:08:12 +00002758 if (getLangOptions().CPlusPlus &&
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002759 (LHSExp->getType()->isRecordType() ||
Eli Friedman254a1a22008-12-15 22:34:21 +00002760 LHSExp->getType()->isEnumeralType() ||
2761 RHSExp->getType()->isRecordType() ||
2762 RHSExp->getType()->isEnumeralType())) {
John McCallb268a282010-08-23 23:25:46 +00002763 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx);
Douglas Gregor40412ac2008-11-19 17:17:41 +00002764 }
2765
John McCallb268a282010-08-23 23:25:46 +00002766 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc);
Sebastian Redladba46e2009-10-29 20:17:01 +00002767}
2768
2769
John McCalldadc5752010-08-24 06:29:42 +00002770ExprResult
John McCallb268a282010-08-23 23:25:46 +00002771Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
2772 Expr *Idx, SourceLocation RLoc) {
2773 Expr *LHSExp = Base;
2774 Expr *RHSExp = Idx;
Sebastian Redladba46e2009-10-29 20:17:01 +00002775
Chris Lattner36d572b2007-07-16 00:14:47 +00002776 // Perform default conversions.
Douglas Gregorb92a1562010-02-03 00:27:59 +00002777 if (!LHSExp->getType()->getAs<VectorType>())
2778 DefaultFunctionArrayLvalueConversion(LHSExp);
2779 DefaultFunctionArrayLvalueConversion(RHSExp);
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002780
Chris Lattner36d572b2007-07-16 00:14:47 +00002781 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
John McCall7decc9e2010-11-18 06:31:45 +00002782 ExprValueKind VK = VK_LValue;
2783 ExprObjectKind OK = OK_Ordinary;
Steve Narofff1e53692007-03-23 22:27:02 +00002784
Steve Naroffc1aadb12007-03-28 21:49:40 +00002785 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
Chris Lattnerf17bd422007-08-30 17:45:32 +00002786 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
Mike Stump4e1f26a2009-02-19 03:04:26 +00002787 // in the subscript position. As a result, we need to derive the array base
Steve Narofff1e53692007-03-23 22:27:02 +00002788 // and index from the expression types.
Chris Lattner36d572b2007-07-16 00:14:47 +00002789 Expr *BaseExpr, *IndexExpr;
2790 QualType ResultType;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00002791 if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
2792 BaseExpr = LHSExp;
2793 IndexExpr = RHSExp;
2794 ResultType = Context.DependentTy;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002795 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
Chris Lattner36d572b2007-07-16 00:14:47 +00002796 BaseExpr = LHSExp;
2797 IndexExpr = RHSExp;
Chris Lattner36d572b2007-07-16 00:14:47 +00002798 ResultType = PTy->getPointeeType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002799 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
Chris Lattneraee0cfd2007-07-16 00:23:25 +00002800 // Handle the uncommon case of "123[Ptr]".
Chris Lattner36d572b2007-07-16 00:14:47 +00002801 BaseExpr = RHSExp;
2802 IndexExpr = LHSExp;
Chris Lattner36d572b2007-07-16 00:14:47 +00002803 ResultType = PTy->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00002804 } else if (const ObjCObjectPointerType *PTy =
John McCall9dd450b2009-09-21 23:43:11 +00002805 LHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00002806 BaseExpr = LHSExp;
2807 IndexExpr = RHSExp;
2808 ResultType = PTy->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00002809 } else if (const ObjCObjectPointerType *PTy =
John McCall9dd450b2009-09-21 23:43:11 +00002810 RHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00002811 // Handle the uncommon case of "123[Ptr]".
2812 BaseExpr = RHSExp;
2813 IndexExpr = LHSExp;
2814 ResultType = PTy->getPointeeType();
John McCall9dd450b2009-09-21 23:43:11 +00002815 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
Chris Lattner41977962007-07-31 19:29:30 +00002816 BaseExpr = LHSExp; // vectors: V[123]
Chris Lattner36d572b2007-07-16 00:14:47 +00002817 IndexExpr = RHSExp;
John McCall7decc9e2010-11-18 06:31:45 +00002818 VK = LHSExp->getValueKind();
2819 if (VK != VK_RValue)
2820 OK = OK_VectorComponent;
Nate Begemanc1bf0612009-01-18 00:45:31 +00002821
Chris Lattner36d572b2007-07-16 00:14:47 +00002822 // FIXME: need to deal with const...
2823 ResultType = VTy->getElementType();
Eli Friedmanab2784f2009-04-25 23:46:54 +00002824 } else if (LHSTy->isArrayType()) {
2825 // If we see an array that wasn't promoted by
Douglas Gregorb92a1562010-02-03 00:27:59 +00002826 // DefaultFunctionArrayLvalueConversion, it must be an array that
Eli Friedmanab2784f2009-04-25 23:46:54 +00002827 // wasn't promoted because of the C90 rule that doesn't
2828 // allow promoting non-lvalue arrays. Warn, then
2829 // force the promotion here.
2830 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
2831 LHSExp->getSourceRange();
Eli Friedman06ed2a52009-10-20 08:27:19 +00002832 ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
John McCalle3027922010-08-25 11:45:40 +00002833 CK_ArrayToPointerDecay);
Eli Friedmanab2784f2009-04-25 23:46:54 +00002834 LHSTy = LHSExp->getType();
2835
2836 BaseExpr = LHSExp;
2837 IndexExpr = RHSExp;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002838 ResultType = LHSTy->getAs<PointerType>()->getPointeeType();
Eli Friedmanab2784f2009-04-25 23:46:54 +00002839 } else if (RHSTy->isArrayType()) {
2840 // Same as previous, except for 123[f().a] case
2841 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
2842 RHSExp->getSourceRange();
Eli Friedman06ed2a52009-10-20 08:27:19 +00002843 ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
John McCalle3027922010-08-25 11:45:40 +00002844 CK_ArrayToPointerDecay);
Eli Friedmanab2784f2009-04-25 23:46:54 +00002845 RHSTy = RHSExp->getType();
2846
2847 BaseExpr = RHSExp;
2848 IndexExpr = LHSExp;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00002849 ResultType = RHSTy->getAs<PointerType>()->getPointeeType();
Steve Naroffb3096442007-06-09 03:47:53 +00002850 } else {
Chris Lattner003af242009-04-25 22:50:55 +00002851 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
2852 << LHSExp->getSourceRange() << RHSExp->getSourceRange());
Sebastian Redlc215cfc2009-01-19 00:08:26 +00002853 }
Steve Naroffc1aadb12007-03-28 21:49:40 +00002854 // C99 6.5.2.1p1
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00002855 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
Chris Lattner003af242009-04-25 22:50:55 +00002856 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
2857 << IndexExpr->getSourceRange());
Steve Naroffb29cdd52007-07-10 18:23:31 +00002858
Daniel Dunbar4782a6e2009-09-17 06:31:17 +00002859 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
Sam Weinigb7608d72009-09-14 20:14:57 +00002860 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
2861 && !IndexExpr->isTypeDependent())
Sam Weinig914244e2009-09-14 01:58:58 +00002862 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();
2863
Douglas Gregorac1fb652009-03-24 19:52:54 +00002864 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
Mike Stump11289f42009-09-09 15:08:12 +00002865 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
2866 // type. Note that Functions are not objects, and that (in C99 parlance)
Douglas Gregorac1fb652009-03-24 19:52:54 +00002867 // incomplete types are not object types.
2868 if (ResultType->isFunctionType()) {
2869 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
2870 << ResultType << BaseExpr->getSourceRange();
2871 return ExprError();
2872 }
Mike Stump11289f42009-09-09 15:08:12 +00002873
Abramo Bagnara3aabb4b2010-09-13 06:50:07 +00002874 if (ResultType->isVoidType() && !getLangOptions().CPlusPlus) {
2875 // GNU extension: subscripting on pointer to void
2876 Diag(LLoc, diag::ext_gnu_void_ptr)
2877 << BaseExpr->getSourceRange();
John McCall4bc41ae2010-11-18 19:01:18 +00002878
2879 // C forbids expressions of unqualified void type from being l-values.
2880 // See IsCForbiddenLValueType.
2881 if (!ResultType.hasQualifiers()) VK = VK_RValue;
Abramo Bagnara3aabb4b2010-09-13 06:50:07 +00002882 } else if (!ResultType->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +00002883 RequireCompleteType(LLoc, ResultType,
Anders Carlssond624e162009-08-26 23:45:07 +00002884 PDiag(diag::err_subscript_incomplete_type)
2885 << BaseExpr->getSourceRange()))
Douglas Gregorac1fb652009-03-24 19:52:54 +00002886 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00002887
Chris Lattner62975a72009-04-24 00:30:45 +00002888 // Diagnose bad cases where we step over interface counts.
John McCall8b07ec22010-05-15 11:32:37 +00002889 if (ResultType->isObjCObjectType() && LangOpts.ObjCNonFragileABI) {
Chris Lattner62975a72009-04-24 00:30:45 +00002890 Diag(LLoc, diag::err_subscript_nonfragile_interface)
2891 << ResultType << BaseExpr->getSourceRange();
2892 return ExprError();
2893 }
Mike Stump11289f42009-09-09 15:08:12 +00002894
John McCall4bc41ae2010-11-18 19:01:18 +00002895 assert(VK == VK_RValue || LangOpts.CPlusPlus ||
2896 !IsCForbiddenLValueType(Context, ResultType));
2897
Mike Stump4e1f26a2009-02-19 03:04:26 +00002898 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
John McCall7decc9e2010-11-18 06:31:45 +00002899 ResultType, VK, OK, RLoc));
Chris Lattnere168f762006-11-10 05:29:30 +00002900}
2901
John McCall4bc41ae2010-11-18 19:01:18 +00002902/// Check an ext-vector component access expression.
2903///
2904/// VK should be set in advance to the value kind of the base
2905/// expression.
2906static QualType
2907CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK,
2908 SourceLocation OpLoc, const IdentifierInfo *CompName,
Anders Carlssonf571c112009-08-26 18:25:21 +00002909 SourceLocation CompLoc) {
Daniel Dunbarc0429402009-10-18 02:09:38 +00002910 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
2911 // see FIXME there.
2912 //
2913 // FIXME: This logic can be greatly simplified by splitting it along
2914 // halving/not halving and reworking the component checking.
John McCall9dd450b2009-09-21 23:43:11 +00002915 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
Nate Begemanf322eab2008-05-09 06:41:27 +00002916
Steve Narofff8fd09e2007-07-27 22:15:19 +00002917 // The vector accessor can't exceed the number of elements.
Daniel Dunbar2c422dc92009-10-18 20:26:12 +00002918 const char *compStr = CompName->getNameStart();
Nate Begemanbb70bf62009-01-18 01:47:54 +00002919
Mike Stump4e1f26a2009-02-19 03:04:26 +00002920 // This flag determines whether or not the component is one of the four
Nate Begemanbb70bf62009-01-18 01:47:54 +00002921 // special names that indicate a subset of exactly half the elements are
2922 // to be selected.
2923 bool HalvingSwizzle = false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00002924
Nate Begemanbb70bf62009-01-18 01:47:54 +00002925 // This flag determines whether or not CompName has an 's' char prefix,
2926 // indicating that it is a string of hex values to be used as vector indices.
Nate Begeman0359e122009-06-25 21:06:09 +00002927 bool HexSwizzle = *compStr == 's' || *compStr == 'S';
Nate Begemanf322eab2008-05-09 06:41:27 +00002928
John McCall4bc41ae2010-11-18 19:01:18 +00002929 bool HasRepeated = false;
2930 bool HasIndex[16] = {};
2931
2932 int Idx;
2933
Nate Begemanf322eab2008-05-09 06:41:27 +00002934 // Check that we've found one of the special components, or that the component
2935 // names must come from the same set.
Mike Stump4e1f26a2009-02-19 03:04:26 +00002936 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
Nate Begemanbb70bf62009-01-18 01:47:54 +00002937 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
2938 HalvingSwizzle = true;
John McCall4bc41ae2010-11-18 19:01:18 +00002939 } else if (!HexSwizzle &&
2940 (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
2941 do {
2942 if (HasIndex[Idx]) HasRepeated = true;
2943 HasIndex[Idx] = true;
Chris Lattner7e152db2007-08-02 22:33:49 +00002944 compStr++;
John McCall4bc41ae2010-11-18 19:01:18 +00002945 } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
2946 } else {
2947 if (HexSwizzle) compStr++;
2948 while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
2949 if (HasIndex[Idx]) HasRepeated = true;
2950 HasIndex[Idx] = true;
Chris Lattner7e152db2007-08-02 22:33:49 +00002951 compStr++;
John McCall4bc41ae2010-11-18 19:01:18 +00002952 }
Chris Lattner7e152db2007-08-02 22:33:49 +00002953 }
Nate Begemanbb70bf62009-01-18 01:47:54 +00002954
Mike Stump4e1f26a2009-02-19 03:04:26 +00002955 if (!HalvingSwizzle && *compStr) {
Steve Narofff8fd09e2007-07-27 22:15:19 +00002956 // We didn't get to the end of the string. This means the component names
2957 // didn't come from the same set *or* we encountered an illegal name.
John McCall4bc41ae2010-11-18 19:01:18 +00002958 S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
Benjamin Kramere8394df2010-08-11 14:47:12 +00002959 << llvm::StringRef(compStr, 1) << SourceRange(CompLoc);
Steve Narofff8fd09e2007-07-27 22:15:19 +00002960 return QualType();
2961 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00002962
Nate Begemanbb70bf62009-01-18 01:47:54 +00002963 // Ensure no component accessor exceeds the width of the vector type it
2964 // operates on.
2965 if (!HalvingSwizzle) {
Daniel Dunbar2c422dc92009-10-18 20:26:12 +00002966 compStr = CompName->getNameStart();
Nate Begemanbb70bf62009-01-18 01:47:54 +00002967
2968 if (HexSwizzle)
Steve Narofff8fd09e2007-07-27 22:15:19 +00002969 compStr++;
Nate Begemanbb70bf62009-01-18 01:47:54 +00002970
2971 while (*compStr) {
2972 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
John McCall4bc41ae2010-11-18 19:01:18 +00002973 S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
Nate Begemanbb70bf62009-01-18 01:47:54 +00002974 << baseType << SourceRange(CompLoc);
2975 return QualType();
2976 }
2977 }
Steve Narofff8fd09e2007-07-27 22:15:19 +00002978 }
Nate Begemanf322eab2008-05-09 06:41:27 +00002979
Steve Narofff8fd09e2007-07-27 22:15:19 +00002980 // The component accessor looks fine - now we need to compute the actual type.
Mike Stump4e1f26a2009-02-19 03:04:26 +00002981 // The vector type is implied by the component accessor. For example,
Steve Narofff8fd09e2007-07-27 22:15:19 +00002982 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
Nate Begemanbb70bf62009-01-18 01:47:54 +00002983 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
Nate Begemanf322eab2008-05-09 06:41:27 +00002984 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
Nate Begemanac8183a2009-12-15 18:13:04 +00002985 unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2
Anders Carlssonf571c112009-08-26 18:25:21 +00002986 : CompName->getLength();
Nate Begemanbb70bf62009-01-18 01:47:54 +00002987 if (HexSwizzle)
2988 CompSize--;
2989
Steve Narofff8fd09e2007-07-27 22:15:19 +00002990 if (CompSize == 1)
2991 return vecType->getElementType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00002992
John McCall4bc41ae2010-11-18 19:01:18 +00002993 if (HasRepeated) VK = VK_RValue;
2994
2995 QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
Mike Stump4e1f26a2009-02-19 03:04:26 +00002996 // Now look up the TypeDefDecl from the vector type. Without this,
Nate Begemance4d7fc2008-04-18 23:10:10 +00002997 // diagostics look bad. We want extended vector types to appear built-in.
John McCall4bc41ae2010-11-18 19:01:18 +00002998 for (unsigned i = 0, E = S.ExtVectorDecls.size(); i != E; ++i) {
2999 if (S.ExtVectorDecls[i]->getUnderlyingType() == VT)
3000 return S.Context.getTypedefType(S.ExtVectorDecls[i]);
Steve Naroffddf5a1d2007-07-29 16:33:31 +00003001 }
3002 return VT; // should never get here (a typedef type should always be found).
Steve Narofff8fd09e2007-07-27 22:15:19 +00003003}
3004
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003005static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
Anders Carlssonf571c112009-08-26 18:25:21 +00003006 IdentifierInfo *Member,
Douglas Gregorbcced4e2009-04-09 21:40:53 +00003007 const Selector &Sel,
3008 ASTContext &Context) {
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003009 if (Member)
3010 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Member))
3011 return PD;
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003012 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003013 return OMD;
Mike Stump11289f42009-09-09 15:08:12 +00003014
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003015 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
3016 E = PDecl->protocol_end(); I != E; ++I) {
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003017 if (Decl *D = FindGetterSetterNameDeclFromProtocolList(*I, Member, Sel,
3018 Context))
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003019 return D;
3020 }
3021 return 0;
3022}
3023
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003024static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy,
3025 IdentifierInfo *Member,
3026 const Selector &Sel,
3027 ASTContext &Context) {
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003028 // Check protocols on qualified interfaces.
3029 Decl *GDecl = 0;
Steve Narofffb4330f2009-06-17 22:40:22 +00003030 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003031 E = QIdTy->qual_end(); I != E; ++I) {
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003032 if (Member)
3033 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
3034 GDecl = PD;
3035 break;
3036 }
3037 // Also must look for a getter or setter name which uses property syntax.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003038 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Sel)) {
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003039 GDecl = OMD;
3040 break;
3041 }
3042 }
3043 if (!GDecl) {
Steve Narofffb4330f2009-06-17 22:40:22 +00003044 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003045 E = QIdTy->qual_end(); I != E; ++I) {
3046 // Search in the protocol-qualifier list of current protocol.
Fariborz Jahanianf3f903a2010-10-11 21:29:12 +00003047 GDecl = FindGetterSetterNameDeclFromProtocolList(*I, Member, Sel,
3048 Context);
Fariborz Jahaniand302bbd02009-03-19 18:15:34 +00003049 if (GDecl)
3050 return GDecl;
3051 }
3052 }
3053 return GDecl;
3054}
Chris Lattner4bf74fd2009-02-15 22:43:40 +00003055
John McCalldadc5752010-08-24 06:29:42 +00003056ExprResult
John McCallb268a282010-08-23 23:25:46 +00003057Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType,
John McCall2d74de92009-12-01 22:10:20 +00003058 bool IsArrow, SourceLocation OpLoc,
John McCall10eae182009-11-30 22:42:35 +00003059 const CXXScopeSpec &SS,
3060 NamedDecl *FirstQualifierInScope,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003061 const DeclarationNameInfo &NameInfo,
John McCall10eae182009-11-30 22:42:35 +00003062 const TemplateArgumentListInfo *TemplateArgs) {
John McCall10eae182009-11-30 22:42:35 +00003063 // Even in dependent contexts, try to diagnose base expressions with
3064 // obviously wrong types, e.g.:
3065 //
3066 // T* t;
3067 // t.f;
3068 //
3069 // In Obj-C++, however, the above expression is valid, since it could be
3070 // accessing the 'f' property if T is an Obj-C interface. The extra check
3071 // allows this, while still reporting an error if T is a struct pointer.
3072 if (!IsArrow) {
John McCall2d74de92009-12-01 22:10:20 +00003073 const PointerType *PT = BaseType->getAs<PointerType>();
John McCall10eae182009-11-30 22:42:35 +00003074 if (PT && (!getLangOptions().ObjC1 ||
3075 PT->getPointeeType()->isRecordType())) {
John McCall2d74de92009-12-01 22:10:20 +00003076 assert(BaseExpr && "cannot happen with implicit member accesses");
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003077 Diag(NameInfo.getLoc(), diag::err_typecheck_member_reference_struct_union)
John McCall2d74de92009-12-01 22:10:20 +00003078 << BaseType << BaseExpr->getSourceRange();
John McCall10eae182009-11-30 22:42:35 +00003079 return ExprError();
3080 }
3081 }
3082
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003083 assert(BaseType->isDependentType() ||
3084 NameInfo.getName().isDependentName() ||
Douglas Gregor41f90302010-04-12 20:54:26 +00003085 isDependentScopeSpecifier(SS));
John McCall10eae182009-11-30 22:42:35 +00003086
3087 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
3088 // must have pointer type, and the accessed type is the pointee.
John McCall2d74de92009-12-01 22:10:20 +00003089 return Owned(CXXDependentScopeMemberExpr::Create(Context, BaseExpr, BaseType,
John McCall10eae182009-11-30 22:42:35 +00003090 IsArrow, OpLoc,
John McCallb268a282010-08-23 23:25:46 +00003091 SS.getScopeRep(),
John McCall10eae182009-11-30 22:42:35 +00003092 SS.getRange(),
3093 FirstQualifierInScope,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003094 NameInfo, TemplateArgs));
John McCall10eae182009-11-30 22:42:35 +00003095}
3096
3097/// We know that the given qualified member reference points only to
3098/// declarations which do not belong to the static type of the base
3099/// expression. Diagnose the problem.
3100static void DiagnoseQualifiedMemberReference(Sema &SemaRef,
3101 Expr *BaseExpr,
3102 QualType BaseType,
John McCallcd4b4772009-12-02 03:53:29 +00003103 const CXXScopeSpec &SS,
John McCall10eae182009-11-30 22:42:35 +00003104 const LookupResult &R) {
John McCallcd4b4772009-12-02 03:53:29 +00003105 // If this is an implicit member access, use a different set of
3106 // diagnostics.
3107 if (!BaseExpr)
3108 return DiagnoseInstanceReference(SemaRef, SS, R);
John McCall10eae182009-11-30 22:42:35 +00003109
John McCall1e67dd62010-04-27 01:43:38 +00003110 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_of_unrelated)
3111 << SS.getRange() << R.getRepresentativeDecl() << BaseType;
John McCall10eae182009-11-30 22:42:35 +00003112}
3113
3114// Check whether the declarations we found through a nested-name
3115// specifier in a member expression are actually members of the base
3116// type. The restriction here is:
3117//
3118// C++ [expr.ref]p2:
3119// ... In these cases, the id-expression shall name a
3120// member of the class or of one of its base classes.
3121//
3122// So it's perfectly legitimate for the nested-name specifier to name
3123// an unrelated class, and for us to find an overload set including
3124// decls from classes which are not superclasses, as long as the decl
3125// we actually pick through overload resolution is from a superclass.
3126bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr,
3127 QualType BaseType,
John McCallcd4b4772009-12-02 03:53:29 +00003128 const CXXScopeSpec &SS,
John McCall10eae182009-11-30 22:42:35 +00003129 const LookupResult &R) {
John McCall2d74de92009-12-01 22:10:20 +00003130 const RecordType *BaseRT = BaseType->getAs<RecordType>();
3131 if (!BaseRT) {
3132 // We can't check this yet because the base type is still
3133 // dependent.
3134 assert(BaseType->isDependentType());
3135 return false;
3136 }
3137 CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(BaseRT->getDecl());
John McCall10eae182009-11-30 22:42:35 +00003138
3139 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
John McCall2d74de92009-12-01 22:10:20 +00003140 // If this is an implicit member reference and we find a
3141 // non-instance member, it's not an error.
John McCalla8ae2222010-04-06 21:38:20 +00003142 if (!BaseExpr && !(*I)->isCXXInstanceMember())
John McCall2d74de92009-12-01 22:10:20 +00003143 return false;
John McCall10eae182009-11-30 22:42:35 +00003144
John McCall2d74de92009-12-01 22:10:20 +00003145 // Note that we use the DC of the decl, not the underlying decl.
Eli Friedman75300492010-07-27 20:51:02 +00003146 DeclContext *DC = (*I)->getDeclContext();
3147 while (DC->isTransparentContext())
3148 DC = DC->getParent();
John McCall2d74de92009-12-01 22:10:20 +00003149
Douglas Gregora9c3e822010-07-28 22:27:52 +00003150 if (!DC->isRecord())
3151 continue;
3152
John McCall2d74de92009-12-01 22:10:20 +00003153 llvm::SmallPtrSet<CXXRecordDecl*,4> MemberRecord;
Eli Friedman75300492010-07-27 20:51:02 +00003154 MemberRecord.insert(cast<CXXRecordDecl>(DC)->getCanonicalDecl());
John McCall2d74de92009-12-01 22:10:20 +00003155
3156 if (!IsProvablyNotDerivedFrom(*this, BaseRecord, MemberRecord))
3157 return false;
3158 }
3159
John McCallcd4b4772009-12-02 03:53:29 +00003160 DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS, R);
John McCall2d74de92009-12-01 22:10:20 +00003161 return true;
3162}
3163
3164static bool
3165LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
3166 SourceRange BaseRange, const RecordType *RTy,
John McCalle9cccd82010-06-16 08:42:20 +00003167 SourceLocation OpLoc, CXXScopeSpec &SS,
3168 bool HasTemplateArgs) {
John McCall2d74de92009-12-01 22:10:20 +00003169 RecordDecl *RDecl = RTy->getDecl();
3170 if (SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
Douglas Gregor89336232010-03-29 23:34:08 +00003171 SemaRef.PDiag(diag::err_typecheck_incomplete_tag)
John McCall2d74de92009-12-01 22:10:20 +00003172 << BaseRange))
3173 return true;
3174
John McCalle9cccd82010-06-16 08:42:20 +00003175 if (HasTemplateArgs) {
3176 // LookupTemplateName doesn't expect these both to exist simultaneously.
3177 QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
3178
3179 bool MOUS;
3180 SemaRef.LookupTemplateName(R, 0, SS, ObjectType, false, MOUS);
3181 return false;
3182 }
3183
John McCall2d74de92009-12-01 22:10:20 +00003184 DeclContext *DC = RDecl;
3185 if (SS.isSet()) {
3186 // If the member name was a qualified-id, look into the
3187 // nested-name-specifier.
3188 DC = SemaRef.computeDeclContext(SS, false);
3189
John McCall0b66eb32010-05-01 00:40:08 +00003190 if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
John McCallcd4b4772009-12-02 03:53:29 +00003191 SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
3192 << SS.getRange() << DC;
3193 return true;
3194 }
3195
John McCall2d74de92009-12-01 22:10:20 +00003196 assert(DC && "Cannot handle non-computable dependent contexts in lookup");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003197
John McCall2d74de92009-12-01 22:10:20 +00003198 if (!isa<TypeDecl>(DC)) {
3199 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
3200 << DC << SS.getRange();
3201 return true;
John McCall10eae182009-11-30 22:42:35 +00003202 }
3203 }
3204
John McCall2d74de92009-12-01 22:10:20 +00003205 // The record definition is complete, now look up the member.
3206 SemaRef.LookupQualifiedName(R, DC);
John McCall10eae182009-11-30 22:42:35 +00003207
Douglas Gregoraf2bd472009-12-31 07:42:17 +00003208 if (!R.empty())
3209 return false;
3210
3211 // We didn't find anything with the given name, so try to correct
3212 // for typos.
3213 DeclarationName Name = R.getLookupName();
Alexis Huntc46382e2010-04-28 23:02:27 +00003214 if (SemaRef.CorrectTypo(R, 0, &SS, DC, false, Sema::CTC_MemberLookup) &&
Douglas Gregor280e1ee2010-04-14 20:04:41 +00003215 !R.empty() &&
Douglas Gregoraf2bd472009-12-31 07:42:17 +00003216 (isa<ValueDecl>(*R.begin()) || isa<FunctionTemplateDecl>(*R.begin()))) {
3217 SemaRef.Diag(R.getNameLoc(), diag::err_no_member_suggest)
3218 << Name << DC << R.getLookupName() << SS.getRange()
Douglas Gregora771f462010-03-31 17:46:05 +00003219 << FixItHint::CreateReplacement(R.getNameLoc(),
3220 R.getLookupName().getAsString());
Douglas Gregor6da83622010-01-07 00:17:44 +00003221 if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
3222 SemaRef.Diag(ND->getLocation(), diag::note_previous_decl)
3223 << ND->getDeclName();
Douglas Gregoraf2bd472009-12-31 07:42:17 +00003224 return false;
3225 } else {
3226 R.clear();
Douglas Gregorc048c522010-06-29 19:27:42 +00003227 R.setLookupName(Name);
Douglas Gregoraf2bd472009-12-31 07:42:17 +00003228 }
3229
John McCall10eae182009-11-30 22:42:35 +00003230 return false;
3231}
3232
John McCalldadc5752010-08-24 06:29:42 +00003233ExprResult
John McCallb268a282010-08-23 23:25:46 +00003234Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
John McCall10eae182009-11-30 22:42:35 +00003235 SourceLocation OpLoc, bool IsArrow,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00003236 CXXScopeSpec &SS,
John McCall10eae182009-11-30 22:42:35 +00003237 NamedDecl *FirstQualifierInScope,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003238 const DeclarationNameInfo &NameInfo,
John McCall10eae182009-11-30 22:42:35 +00003239 const TemplateArgumentListInfo *TemplateArgs) {
John McCallcd4b4772009-12-02 03:53:29 +00003240 if (BaseType->isDependentType() ||
3241 (SS.isSet() && isDependentScopeSpecifier(SS)))
John McCallb268a282010-08-23 23:25:46 +00003242 return ActOnDependentMemberExpr(Base, BaseType,
John McCall10eae182009-11-30 22:42:35 +00003243 IsArrow, OpLoc,
3244 SS, FirstQualifierInScope,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003245 NameInfo, TemplateArgs);
John McCall10eae182009-11-30 22:42:35 +00003246
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003247 LookupResult R(*this, NameInfo, LookupMemberName);
John McCall10eae182009-11-30 22:42:35 +00003248
John McCall2d74de92009-12-01 22:10:20 +00003249 // Implicit member accesses.
3250 if (!Base) {
3251 QualType RecordTy = BaseType;
3252 if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType();
3253 if (LookupMemberExprInRecord(*this, R, SourceRange(),
3254 RecordTy->getAs<RecordType>(),
John McCalle9cccd82010-06-16 08:42:20 +00003255 OpLoc, SS, TemplateArgs != 0))
John McCall2d74de92009-12-01 22:10:20 +00003256 return ExprError();
3257
3258 // Explicit member accesses.
3259 } else {
John McCalldadc5752010-08-24 06:29:42 +00003260 ExprResult Result =
John McCall2d74de92009-12-01 22:10:20 +00003261 LookupMemberExpr(R, Base, IsArrow, OpLoc,
John McCall48871652010-08-21 09:40:31 +00003262 SS, /*ObjCImpDecl*/ 0, TemplateArgs != 0);
John McCall2d74de92009-12-01 22:10:20 +00003263
3264 if (Result.isInvalid()) {
3265 Owned(Base);
3266 return ExprError();
3267 }
3268
3269 if (Result.get())
3270 return move(Result);
Sebastian Redlfa1f70f2010-05-07 09:25:11 +00003271
3272 // LookupMemberExpr can modify Base, and thus change BaseType
3273 BaseType = Base->getType();
John McCall10eae182009-11-30 22:42:35 +00003274 }
3275
John McCallb268a282010-08-23 23:25:46 +00003276 return BuildMemberReferenceExpr(Base, BaseType,
John McCall38836f02010-01-15 08:34:02 +00003277 OpLoc, IsArrow, SS, FirstQualifierInScope,
3278 R, TemplateArgs);
John McCall10eae182009-11-30 22:42:35 +00003279}
3280
John McCalldadc5752010-08-24 06:29:42 +00003281ExprResult
John McCallb268a282010-08-23 23:25:46 +00003282Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
John McCall2d74de92009-12-01 22:10:20 +00003283 SourceLocation OpLoc, bool IsArrow,
3284 const CXXScopeSpec &SS,
John McCall38836f02010-01-15 08:34:02 +00003285 NamedDecl *FirstQualifierInScope,
John McCall10eae182009-11-30 22:42:35 +00003286 LookupResult &R,
Douglas Gregorb139cd52010-05-01 20:49:11 +00003287 const TemplateArgumentListInfo *TemplateArgs,
3288 bool SuppressQualifierCheck) {
John McCall2d74de92009-12-01 22:10:20 +00003289 QualType BaseType = BaseExprType;
John McCall10eae182009-11-30 22:42:35 +00003290 if (IsArrow) {
3291 assert(BaseType->isPointerType());
3292 BaseType = BaseType->getAs<PointerType>()->getPointeeType();
3293 }
John McCalla8ae2222010-04-06 21:38:20 +00003294 R.setBaseObjectType(BaseType);
John McCall10eae182009-11-30 22:42:35 +00003295
John McCallb268a282010-08-23 23:25:46 +00003296 NestedNameSpecifier *Qualifier = SS.getScopeRep();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003297 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
3298 DeclarationName MemberName = MemberNameInfo.getName();
3299 SourceLocation MemberLoc = MemberNameInfo.getLoc();
John McCall10eae182009-11-30 22:42:35 +00003300
3301 if (R.isAmbiguous())
Douglas Gregord8061562009-08-06 03:17:00 +00003302 return ExprError();
3303
John McCall10eae182009-11-30 22:42:35 +00003304 if (R.empty()) {
3305 // Rederive where we looked up.
3306 DeclContext *DC = (SS.isSet()
3307 ? computeDeclContext(SS, false)
3308 : BaseType->getAs<RecordType>()->getDecl());
Nate Begeman5ec4b312009-08-10 23:49:36 +00003309
John McCall10eae182009-11-30 22:42:35 +00003310 Diag(R.getNameLoc(), diag::err_no_member)
John McCall2d74de92009-12-01 22:10:20 +00003311 << MemberName << DC
3312 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
John McCall10eae182009-11-30 22:42:35 +00003313 return ExprError();
3314 }
3315
John McCall38836f02010-01-15 08:34:02 +00003316 // Diagnose lookups that find only declarations from a non-base
3317 // type. This is possible for either qualified lookups (which may
3318 // have been qualified with an unrelated type) or implicit member
3319 // expressions (which were found with unqualified lookup and thus
3320 // may have come from an enclosing scope). Note that it's okay for
3321 // lookup to find declarations from a non-base type as long as those
3322 // aren't the ones picked by overload resolution.
3323 if ((SS.isSet() || !BaseExpr ||
3324 (isa<CXXThisExpr>(BaseExpr) &&
3325 cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
Douglas Gregorb139cd52010-05-01 20:49:11 +00003326 !SuppressQualifierCheck &&
John McCall38836f02010-01-15 08:34:02 +00003327 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
John McCall10eae182009-11-30 22:42:35 +00003328 return ExprError();
3329
3330 // Construct an unresolved result if we in fact got an unresolved
3331 // result.
3332 if (R.isOverloadedResult() || R.isUnresolvableResult()) {
John McCall58cc69d2010-01-27 01:50:18 +00003333 // Suppress any lookup-related diagnostics; we'll do these when we
3334 // pick a member.
3335 R.suppressDiagnostics();
3336
John McCall10eae182009-11-30 22:42:35 +00003337 UnresolvedMemberExpr *MemExpr
Douglas Gregora6e053e2010-12-15 01:34:56 +00003338 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(),
John McCall2d74de92009-12-01 22:10:20 +00003339 BaseExpr, BaseExprType,
3340 IsArrow, OpLoc,
John McCall10eae182009-11-30 22:42:35 +00003341 Qualifier, SS.getRange(),
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003342 MemberNameInfo,
Douglas Gregor30a4f4c2010-05-23 18:57:34 +00003343 TemplateArgs, R.begin(), R.end());
John McCall10eae182009-11-30 22:42:35 +00003344
3345 return Owned(MemExpr);
3346 }
3347
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003348 assert(R.isSingleResult());
John McCalla8ae2222010-04-06 21:38:20 +00003349 DeclAccessPair FoundDecl = R.begin().getPair();
John McCall10eae182009-11-30 22:42:35 +00003350 NamedDecl *MemberDecl = R.getFoundDecl();
3351
3352 // FIXME: diagnose the presence of template arguments now.
3353
3354 // If the decl being referenced had an error, return an error for this
3355 // sub-expr without emitting another error, in order to avoid cascading
3356 // error cases.
3357 if (MemberDecl->isInvalidDecl())
3358 return ExprError();
3359
John McCall2d74de92009-12-01 22:10:20 +00003360 // Handle the implicit-member-access case.
3361 if (!BaseExpr) {
3362 // If this is not an instance member, convert to a non-member access.
John McCalla8ae2222010-04-06 21:38:20 +00003363 if (!MemberDecl->isCXXInstanceMember())
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003364 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl);
John McCall2d74de92009-12-01 22:10:20 +00003365
Douglas Gregorb15af892010-01-07 23:12:05 +00003366 SourceLocation Loc = R.getNameLoc();
3367 if (SS.getRange().isValid())
3368 Loc = SS.getRange().getBegin();
3369 BaseExpr = new (Context) CXXThisExpr(Loc, BaseExprType,/*isImplicit=*/true);
John McCall2d74de92009-12-01 22:10:20 +00003370 }
3371
John McCall10eae182009-11-30 22:42:35 +00003372 bool ShouldCheckUse = true;
3373 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MemberDecl)) {
3374 // Don't diagnose the use of a virtual member function unless it's
3375 // explicitly qualified.
3376 if (MD->isVirtual() && !SS.isSet())
3377 ShouldCheckUse = false;
3378 }
3379
3380 // Check the use of this member.
3381 if (ShouldCheckUse && DiagnoseUseOfDecl(MemberDecl, MemberLoc)) {
3382 Owned(BaseExpr);
3383 return ExprError();
3384 }
3385
John McCall34376a62010-12-04 03:47:34 +00003386 // Perform a property load on the base regardless of whether we
3387 // actually need it for the declaration.
3388 if (BaseExpr->getObjectKind() == OK_ObjCProperty)
3389 ConvertPropertyForRValue(BaseExpr);
3390
John McCallfeb624a2010-11-23 20:48:44 +00003391 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
3392 return BuildFieldReferenceExpr(*this, BaseExpr, IsArrow,
3393 SS, FD, FoundDecl, MemberNameInfo);
John McCall10eae182009-11-30 22:42:35 +00003394
Francois Pichet783dd6e2010-11-21 06:08:52 +00003395 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
3396 // We may have found a field within an anonymous union or struct
3397 // (C++ [class.union]).
3398 return BuildAnonymousStructUnionMemberReference(MemberLoc, FD,
John McCall34376a62010-12-04 03:47:34 +00003399 BaseExpr, OpLoc);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003400
John McCall10eae182009-11-30 22:42:35 +00003401 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
3402 MarkDeclarationReferenced(MemberLoc, Var);
3403 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003404 Var, FoundDecl, MemberNameInfo,
John McCall7decc9e2010-11-18 06:31:45 +00003405 Var->getType().getNonReferenceType(),
John McCall4bc41ae2010-11-18 19:01:18 +00003406 VK_LValue, OK_Ordinary));
John McCall10eae182009-11-30 22:42:35 +00003407 }
3408
John McCall7decc9e2010-11-18 06:31:45 +00003409 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
John McCall10eae182009-11-30 22:42:35 +00003410 MarkDeclarationReferenced(MemberLoc, MemberDecl);
3411 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003412 MemberFn, FoundDecl, MemberNameInfo,
John McCall7decc9e2010-11-18 06:31:45 +00003413 MemberFn->getType(),
3414 MemberFn->isInstance() ? VK_RValue : VK_LValue,
3415 OK_Ordinary));
John McCall10eae182009-11-30 22:42:35 +00003416 }
John McCall7decc9e2010-11-18 06:31:45 +00003417 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
John McCall10eae182009-11-30 22:42:35 +00003418
3419 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
3420 MarkDeclarationReferenced(MemberLoc, MemberDecl);
3421 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003422 Enum, FoundDecl, MemberNameInfo,
John McCall7decc9e2010-11-18 06:31:45 +00003423 Enum->getType(), VK_RValue, OK_Ordinary));
John McCall10eae182009-11-30 22:42:35 +00003424 }
3425
3426 Owned(BaseExpr);
3427
Douglas Gregor861eb802010-04-25 20:55:08 +00003428 // We found something that we didn't expect. Complain.
John McCall10eae182009-11-30 22:42:35 +00003429 if (isa<TypeDecl>(MemberDecl))
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003430 Diag(MemberLoc, diag::err_typecheck_member_reference_type)
Douglas Gregor861eb802010-04-25 20:55:08 +00003431 << MemberName << BaseType << int(IsArrow);
3432 else
3433 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
3434 << MemberName << BaseType << int(IsArrow);
John McCall10eae182009-11-30 22:42:35 +00003435
Douglas Gregor861eb802010-04-25 20:55:08 +00003436 Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
3437 << MemberName;
Douglas Gregor516d6722010-04-25 21:15:30 +00003438 R.suppressDiagnostics();
Douglas Gregor861eb802010-04-25 20:55:08 +00003439 return ExprError();
John McCall10eae182009-11-30 22:42:35 +00003440}
3441
John McCall68fc88ec2010-12-15 16:46:44 +00003442/// Given that normal member access failed on the given expression,
3443/// and given that the expression's type involves builtin-id or
3444/// builtin-Class, decide whether substituting in the redefinition
3445/// types would be profitable. The redefinition type is whatever
3446/// this translation unit tried to typedef to id/Class; we store
3447/// it to the side and then re-use it in places like this.
3448static bool ShouldTryAgainWithRedefinitionType(Sema &S, Expr *&base) {
3449 const ObjCObjectPointerType *opty
3450 = base->getType()->getAs<ObjCObjectPointerType>();
3451 if (!opty) return false;
3452
3453 const ObjCObjectType *ty = opty->getObjectType();
3454
3455 QualType redef;
3456 if (ty->isObjCId()) {
3457 redef = S.Context.ObjCIdRedefinitionType;
3458 } else if (ty->isObjCClass()) {
3459 redef = S.Context.ObjCClassRedefinitionType;
3460 } else {
3461 return false;
3462 }
3463
3464 // Do the substitution as long as the redefinition type isn't just a
3465 // possibly-qualified pointer to builtin-id or builtin-Class again.
3466 opty = redef->getAs<ObjCObjectPointerType>();
3467 if (opty && !opty->getObjectType()->getInterface() != 0)
3468 return false;
3469
3470 S.ImpCastExprToType(base, redef, CK_BitCast);
3471 return true;
3472}
3473
John McCall10eae182009-11-30 22:42:35 +00003474/// Look up the given member of the given non-type-dependent
3475/// expression. This can return in one of two ways:
3476/// * If it returns a sentinel null-but-valid result, the caller will
3477/// assume that lookup was performed and the results written into
3478/// the provided structure. It will take over from there.
3479/// * Otherwise, the returned expression will be produced in place of
3480/// an ordinary member expression.
3481///
3482/// The ObjCImpDecl bit is a gross hack that will need to be properly
3483/// fixed for ObjC++.
John McCalldadc5752010-08-24 06:29:42 +00003484ExprResult
John McCall10eae182009-11-30 22:42:35 +00003485Sema::LookupMemberExpr(LookupResult &R, Expr *&BaseExpr,
John McCalla928c652009-12-07 22:46:59 +00003486 bool &IsArrow, SourceLocation OpLoc,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00003487 CXXScopeSpec &SS,
John McCall48871652010-08-21 09:40:31 +00003488 Decl *ObjCImpDecl, bool HasTemplateArgs) {
Douglas Gregorad8a3362009-09-04 17:36:40 +00003489 assert(BaseExpr && "no base expression");
Mike Stump11289f42009-09-09 15:08:12 +00003490
Steve Naroffeaaae462007-12-16 21:42:28 +00003491 // Perform default conversions.
3492 DefaultFunctionArrayConversion(BaseExpr);
John McCall15317a22010-12-15 04:42:30 +00003493 if (IsArrow) DefaultLvalueConversion(BaseExpr);
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003494
Steve Naroff185616f2007-07-26 03:11:44 +00003495 QualType BaseType = BaseExpr->getType();
John McCall10eae182009-11-30 22:42:35 +00003496 assert(!BaseType->isDependentType());
3497
3498 DeclarationName MemberName = R.getLookupName();
3499 SourceLocation MemberLoc = R.getNameLoc();
Douglas Gregord82ae382009-11-06 06:30:47 +00003500
John McCall68fc88ec2010-12-15 16:46:44 +00003501 // For later type-checking purposes, turn arrow accesses into dot
3502 // accesses. The only access type we support that doesn't follow
3503 // the C equivalence "a->b === (*a).b" is ObjC property accesses,
3504 // and those never use arrows, so this is unaffected.
3505 if (IsArrow) {
3506 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3507 BaseType = Ptr->getPointeeType();
3508 else if (const ObjCObjectPointerType *Ptr
3509 = BaseType->getAs<ObjCObjectPointerType>())
3510 BaseType = Ptr->getPointeeType();
3511 else if (BaseType->isRecordType()) {
3512 // Recover from arrow accesses to records, e.g.:
3513 // struct MyRecord foo;
3514 // foo->bar
3515 // This is actually well-formed in C++ if MyRecord has an
3516 // overloaded operator->, but that should have been dealt with
3517 // by now.
3518 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
3519 << BaseType << int(IsArrow) << BaseExpr->getSourceRange()
3520 << FixItHint::CreateReplacement(OpLoc, ".");
3521 IsArrow = false;
3522 } else {
3523 Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
3524 << BaseType << BaseExpr->getSourceRange();
3525 return ExprError();
Douglas Gregord82ae382009-11-06 06:30:47 +00003526 }
3527 }
3528
John McCall68fc88ec2010-12-15 16:46:44 +00003529 // Handle field access to simple records.
3530 if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
3531 if (LookupMemberExprInRecord(*this, R, BaseExpr->getSourceRange(),
3532 RTy, OpLoc, SS, HasTemplateArgs))
3533 return ExprError();
3534
3535 // Returning valid-but-null is how we indicate to the caller that
3536 // the lookup result was filled in.
3537 return Owned((Expr*) 0);
David Chisnall9f57c292009-08-17 16:35:33 +00003538 }
John McCall10eae182009-11-30 22:42:35 +00003539
John McCall68fc88ec2010-12-15 16:46:44 +00003540 // Handle ivar access to Objective-C objects.
3541 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003542 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
John McCall68fc88ec2010-12-15 16:46:44 +00003543
3544 // There are three cases for the base type:
3545 // - builtin id (qualified or unqualified)
3546 // - builtin Class (qualified or unqualified)
3547 // - an interface
3548 ObjCInterfaceDecl *IDecl = OTy->getInterface();
3549 if (!IDecl) {
3550 // There's an implicit 'isa' ivar on all objects.
3551 // But we only actually find it this way on objects of type 'id',
3552 // apparently.
3553 if (OTy->isObjCId() && Member->isStr("isa"))
3554 return Owned(new (Context) ObjCIsaExpr(BaseExpr, IsArrow, MemberLoc,
3555 Context.getObjCClassType()));
3556
3557 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
3558 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3559 ObjCImpDecl, HasTemplateArgs);
3560 goto fail;
3561 }
3562
3563 ObjCInterfaceDecl *ClassDeclared;
3564 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
3565
3566 if (!IV) {
3567 // Attempt to correct for typos in ivar names.
3568 LookupResult Res(*this, R.getLookupName(), R.getNameLoc(),
3569 LookupMemberName);
3570 if (CorrectTypo(Res, 0, 0, IDecl, false,
3571 IsArrow ? CTC_ObjCIvarLookup
3572 : CTC_ObjCPropertyLookup) &&
3573 (IV = Res.getAsSingle<ObjCIvarDecl>())) {
3574 Diag(R.getNameLoc(),
3575 diag::err_typecheck_member_reference_ivar_suggest)
3576 << IDecl->getDeclName() << MemberName << IV->getDeclName()
3577 << FixItHint::CreateReplacement(R.getNameLoc(),
3578 IV->getNameAsString());
3579 Diag(IV->getLocation(), diag::note_previous_decl)
3580 << IV->getDeclName();
3581 } else {
3582 Res.clear();
3583 Res.setLookupName(Member);
3584
3585 Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
3586 << IDecl->getDeclName() << MemberName
3587 << BaseExpr->getSourceRange();
3588 return ExprError();
3589 }
3590 }
3591
3592 // If the decl being referenced had an error, return an error for this
3593 // sub-expr without emitting another error, in order to avoid cascading
3594 // error cases.
3595 if (IV->isInvalidDecl())
3596 return ExprError();
3597
3598 // Check whether we can reference this field.
3599 if (DiagnoseUseOfDecl(IV, MemberLoc))
3600 return ExprError();
3601 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
3602 IV->getAccessControl() != ObjCIvarDecl::Package) {
3603 ObjCInterfaceDecl *ClassOfMethodDecl = 0;
3604 if (ObjCMethodDecl *MD = getCurMethodDecl())
3605 ClassOfMethodDecl = MD->getClassInterface();
3606 else if (ObjCImpDecl && getCurFunctionDecl()) {
3607 // Case of a c-function declared inside an objc implementation.
3608 // FIXME: For a c-style function nested inside an objc implementation
3609 // class, there is no implementation context available, so we pass
3610 // down the context as argument to this routine. Ideally, this context
3611 // need be passed down in the AST node and somehow calculated from the
3612 // AST for a function decl.
3613 if (ObjCImplementationDecl *IMPD =
3614 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
3615 ClassOfMethodDecl = IMPD->getClassInterface();
3616 else if (ObjCCategoryImplDecl* CatImplClass =
3617 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
3618 ClassOfMethodDecl = CatImplClass->getClassInterface();
3619 }
3620
3621 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
3622 if (ClassDeclared != IDecl ||
3623 ClassOfMethodDecl != ClassDeclared)
3624 Diag(MemberLoc, diag::error_private_ivar_access)
3625 << IV->getDeclName();
3626 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
3627 // @protected
3628 Diag(MemberLoc, diag::error_protected_ivar_access)
3629 << IV->getDeclName();
3630 }
3631
3632 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(),
3633 MemberLoc, BaseExpr,
3634 IsArrow));
3635 }
3636
3637 // Objective-C property access.
3638 const ObjCObjectPointerType *OPT;
3639 if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
3640 // This actually uses the base as an r-value.
3641 DefaultLvalueConversion(BaseExpr);
3642 assert(Context.hasSameUnqualifiedType(BaseType, BaseExpr->getType()));
3643
3644 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
3645
3646 const ObjCObjectType *OT = OPT->getObjectType();
3647
3648 // id, with and without qualifiers.
3649 if (OT->isObjCId()) {
3650 // Check protocols on qualified interfaces.
3651 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
3652 if (Decl *PMDecl = FindGetterSetterNameDecl(OPT, Member, Sel, Context)) {
3653 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
3654 // Check the use of this declaration
3655 if (DiagnoseUseOfDecl(PD, MemberLoc))
3656 return ExprError();
3657
3658 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
3659 VK_LValue,
3660 OK_ObjCProperty,
3661 MemberLoc,
3662 BaseExpr));
3663 }
3664
3665 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
3666 // Check the use of this method.
3667 if (DiagnoseUseOfDecl(OMD, MemberLoc))
3668 return ExprError();
3669 Selector SetterSel =
3670 SelectorTable::constructSetterName(PP.getIdentifierTable(),
3671 PP.getSelectorTable(), Member);
3672 ObjCMethodDecl *SMD = 0;
3673 if (Decl *SDecl = FindGetterSetterNameDecl(OPT, /*Property id*/0,
3674 SetterSel, Context))
3675 SMD = dyn_cast<ObjCMethodDecl>(SDecl);
3676 QualType PType = OMD->getSendResultType();
3677
3678 ExprValueKind VK = VK_LValue;
3679 if (!getLangOptions().CPlusPlus &&
3680 IsCForbiddenLValueType(Context, PType))
3681 VK = VK_RValue;
3682 ExprObjectKind OK = (VK == VK_RValue ? OK_Ordinary : OK_ObjCProperty);
3683
3684 return Owned(new (Context) ObjCPropertyRefExpr(OMD, SMD, PType,
3685 VK, OK,
3686 MemberLoc, BaseExpr));
3687 }
3688 }
3689
3690 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
3691 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3692 ObjCImpDecl, HasTemplateArgs);
3693
3694 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
3695 << MemberName << BaseType);
3696 }
3697
3698 // 'Class', unqualified only.
3699 if (OT->isObjCClass()) {
3700 // Only works in a method declaration (??!).
3701 ObjCMethodDecl *MD = getCurMethodDecl();
3702 if (!MD) {
3703 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
3704 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3705 ObjCImpDecl, HasTemplateArgs);
3706
3707 goto fail;
3708 }
3709
3710 // Also must look for a getter name which uses property syntax.
3711 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003712 ObjCInterfaceDecl *IFace = MD->getClassInterface();
3713 ObjCMethodDecl *Getter;
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003714 if ((Getter = IFace->lookupClassMethod(Sel))) {
3715 // Check the use of this method.
3716 if (DiagnoseUseOfDecl(Getter, MemberLoc))
3717 return ExprError();
John McCall68fc88ec2010-12-15 16:46:44 +00003718 } else
Fariborz Jahanianecbbb6e2010-12-03 23:37:08 +00003719 Getter = IFace->lookupPrivateMethod(Sel, false);
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003720 // If we found a getter then this may be a valid dot-reference, we
3721 // will look for the matching setter, in case it is needed.
3722 Selector SetterSel =
John McCall68fc88ec2010-12-15 16:46:44 +00003723 SelectorTable::constructSetterName(PP.getIdentifierTable(),
3724 PP.getSelectorTable(), Member);
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003725 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
3726 if (!Setter) {
3727 // If this reference is in an @implementation, also check for 'private'
3728 // methods.
Fariborz Jahanianecbbb6e2010-12-03 23:37:08 +00003729 Setter = IFace->lookupPrivateMethod(SetterSel, false);
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003730 }
3731 // Look through local category implementations associated with the class.
3732 if (!Setter)
3733 Setter = IFace->getCategoryClassMethod(SetterSel);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003734
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003735 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
3736 return ExprError();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003737
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003738 if (Getter || Setter) {
3739 QualType PType;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003740
John McCall4bc41ae2010-11-18 19:01:18 +00003741 ExprValueKind VK = VK_LValue;
3742 if (Getter) {
Douglas Gregor603d81b2010-07-13 08:18:22 +00003743 PType = Getter->getSendResultType();
John McCall4bc41ae2010-11-18 19:01:18 +00003744 if (!getLangOptions().CPlusPlus &&
3745 IsCForbiddenLValueType(Context, PType))
3746 VK = VK_RValue;
3747 } else {
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003748 // Get the expression type from Setter's incoming parameter.
3749 PType = (*(Setter->param_end() -1))->getType();
John McCall4bc41ae2010-11-18 19:01:18 +00003750 }
3751 ExprObjectKind OK = (VK == VK_RValue ? OK_Ordinary : OK_ObjCProperty);
3752
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003753 // FIXME: we must check that the setter has property type.
John McCallb7bd14f2010-12-02 01:19:52 +00003754 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
3755 PType, VK, OK,
3756 MemberLoc, BaseExpr));
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003757 }
John McCall68fc88ec2010-12-15 16:46:44 +00003758
3759 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
3760 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3761 ObjCImpDecl, HasTemplateArgs);
3762
Fariborz Jahaniane983d172009-09-22 16:48:37 +00003763 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
John McCall68fc88ec2010-12-15 16:46:44 +00003764 << MemberName << BaseType);
Steve Naroff7cae42b2009-07-10 23:34:53 +00003765 }
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003766
John McCall68fc88ec2010-12-15 16:46:44 +00003767 // Normal property access.
3768 return HandleExprPropertyRefExpr(OPT, BaseExpr, MemberName, MemberLoc,
3769 SourceLocation(), QualType(), false);
Steve Naroff7cae42b2009-07-10 23:34:53 +00003770 }
Alexis Huntc46382e2010-04-28 23:02:27 +00003771
Chris Lattnerb63a7452008-07-21 04:28:12 +00003772 // Handle 'field access' to vectors, such as 'V.xx'.
Chris Lattner6c7ce102009-02-16 21:11:58 +00003773 if (BaseType->isExtVectorType()) {
John McCall15317a22010-12-15 04:42:30 +00003774 // FIXME: this expr should store IsArrow.
Anders Carlssonf571c112009-08-26 18:25:21 +00003775 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
John McCall15317a22010-12-15 04:42:30 +00003776 ExprValueKind VK = (IsArrow ? VK_LValue : BaseExpr->getValueKind());
John McCall4bc41ae2010-11-18 19:01:18 +00003777 QualType ret = CheckExtVectorComponent(*this, BaseType, VK, OpLoc,
3778 Member, MemberLoc);
Chris Lattnerb63a7452008-07-21 04:28:12 +00003779 if (ret.isNull())
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003780 return ExprError();
John McCall4bc41ae2010-11-18 19:01:18 +00003781
3782 return Owned(new (Context) ExtVectorElementExpr(ret, VK, BaseExpr,
3783 *Member, MemberLoc));
Chris Lattnerb63a7452008-07-21 04:28:12 +00003784 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003785
John McCall68fc88ec2010-12-15 16:46:44 +00003786 // Adjust builtin-sel to the appropriate redefinition type if that's
3787 // not just a pointer to builtin-sel again.
3788 if (IsArrow &&
3789 BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
3790 !Context.ObjCSelRedefinitionType->isObjCSelType()) {
3791 ImpCastExprToType(BaseExpr, Context.ObjCSelRedefinitionType, CK_BitCast);
3792 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3793 ObjCImpDecl, HasTemplateArgs);
3794 }
3795
3796 // Failure cases.
3797 fail:
3798
3799 // There's a possible road to recovery for function types.
3800 const FunctionType *Fun = 0;
3801
3802 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
3803 if ((Fun = Ptr->getPointeeType()->getAs<FunctionType>())) {
3804 // fall out, handled below.
3805
3806 // Recover from dot accesses to pointers, e.g.:
3807 // type *foo;
3808 // foo.bar
3809 // This is actually well-formed in two cases:
3810 // - 'type' is an Objective C type
3811 // - 'bar' is a pseudo-destructor name which happens to refer to
3812 // the appropriate pointer type
3813 } else if (Ptr->getPointeeType()->isRecordType() &&
3814 MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
3815 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
3816 << BaseType << int(IsArrow) << BaseExpr->getSourceRange()
3817 << FixItHint::CreateReplacement(OpLoc, "->");
3818
3819 // Recurse as an -> access.
3820 IsArrow = true;
3821 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3822 ObjCImpDecl, HasTemplateArgs);
3823 }
3824 } else {
3825 Fun = BaseType->getAs<FunctionType>();
3826 }
3827
3828 // If the user is trying to apply -> or . to a function pointer
3829 // type, it's probably because they forgot parentheses to call that
3830 // function. Suggest the addition of those parentheses, build the
3831 // call, and continue on.
3832 if (Fun || BaseType == Context.OverloadTy) {
3833 bool TryCall;
3834 if (BaseType == Context.OverloadTy) {
3835 TryCall = true;
3836 } else {
3837 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(Fun)) {
3838 TryCall = (FPT->getNumArgs() == 0);
3839 } else {
3840 TryCall = true;
3841 }
3842
3843 if (TryCall) {
3844 QualType ResultTy = Fun->getResultType();
3845 TryCall = (!IsArrow && ResultTy->isRecordType()) ||
3846 (IsArrow && ResultTy->isPointerType() &&
3847 ResultTy->getAs<PointerType>()->getPointeeType()->isRecordType());
3848 }
3849 }
3850
3851
3852 if (TryCall) {
3853 SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd());
3854 Diag(BaseExpr->getExprLoc(), diag::err_member_reference_needs_call)
3855 << QualType(Fun, 0)
3856 << FixItHint::CreateInsertion(Loc, "()");
3857
3858 ExprResult NewBase
3859 = ActOnCallExpr(0, BaseExpr, Loc, MultiExprArg(*this, 0, 0), Loc);
3860 if (NewBase.isInvalid())
3861 return ExprError();
3862 BaseExpr = NewBase.takeAs<Expr>();
3863
3864
3865 DefaultFunctionArrayConversion(BaseExpr);
3866 BaseType = BaseExpr->getType();
3867
3868 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
3869 ObjCImpDecl, HasTemplateArgs);
3870 }
3871 }
3872
Douglas Gregor0b08ba42009-03-27 06:00:30 +00003873 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union)
3874 << BaseType << BaseExpr->getSourceRange();
3875
Douglas Gregor0b08ba42009-03-27 06:00:30 +00003876 return ExprError();
Chris Lattnere168f762006-11-10 05:29:30 +00003877}
3878
John McCall10eae182009-11-30 22:42:35 +00003879/// The main callback when the parser finds something like
3880/// expression . [nested-name-specifier] identifier
3881/// expression -> [nested-name-specifier] identifier
3882/// where 'identifier' encompasses a fairly broad spectrum of
3883/// possibilities, including destructor and operator references.
3884///
3885/// \param OpKind either tok::arrow or tok::period
3886/// \param HasTrailingLParen whether the next token is '(', which
3887/// is used to diagnose mis-uses of special members that can
3888/// only be called
3889/// \param ObjCImpDecl the current ObjC @implementation decl;
3890/// this is an ugly hack around the fact that ObjC @implementations
3891/// aren't properly put in the context chain
John McCalldadc5752010-08-24 06:29:42 +00003892ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
John McCall15317a22010-12-15 04:42:30 +00003893 SourceLocation OpLoc,
3894 tok::TokenKind OpKind,
3895 CXXScopeSpec &SS,
3896 UnqualifiedId &Id,
3897 Decl *ObjCImpDecl,
3898 bool HasTrailingLParen) {
John McCall10eae182009-11-30 22:42:35 +00003899 if (SS.isSet() && SS.isInvalid())
3900 return ExprError();
3901
3902 TemplateArgumentListInfo TemplateArgsBuffer;
3903
3904 // Decompose the name into its component parts.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003905 DeclarationNameInfo NameInfo;
John McCall10eae182009-11-30 22:42:35 +00003906 const TemplateArgumentListInfo *TemplateArgs;
3907 DecomposeUnqualifiedId(*this, Id, TemplateArgsBuffer,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003908 NameInfo, TemplateArgs);
John McCall10eae182009-11-30 22:42:35 +00003909
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003910 DeclarationName Name = NameInfo.getName();
John McCall10eae182009-11-30 22:42:35 +00003911 bool IsArrow = (OpKind == tok::arrow);
3912
3913 NamedDecl *FirstQualifierInScope
3914 = (!SS.isSet() ? 0 : FindFirstQualifierInScope(S,
3915 static_cast<NestedNameSpecifier*>(SS.getScopeRep())));
3916
3917 // This is a postfix expression, so get rid of ParenListExprs.
John McCalldadc5752010-08-24 06:29:42 +00003918 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
John McCallb268a282010-08-23 23:25:46 +00003919 if (Result.isInvalid()) return ExprError();
3920 Base = Result.take();
John McCall10eae182009-11-30 22:42:35 +00003921
Douglas Gregor41f90302010-04-12 20:54:26 +00003922 if (Base->getType()->isDependentType() || Name.isDependentName() ||
3923 isDependentScopeSpecifier(SS)) {
John McCallb268a282010-08-23 23:25:46 +00003924 Result = ActOnDependentMemberExpr(Base, Base->getType(),
John McCall10eae182009-11-30 22:42:35 +00003925 IsArrow, OpLoc,
3926 SS, FirstQualifierInScope,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003927 NameInfo, TemplateArgs);
John McCall10eae182009-11-30 22:42:35 +00003928 } else {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003929 LookupResult R(*this, NameInfo, LookupMemberName);
John McCalle9cccd82010-06-16 08:42:20 +00003930 Result = LookupMemberExpr(R, Base, IsArrow, OpLoc,
3931 SS, ObjCImpDecl, TemplateArgs != 0);
Alexis Huntc46382e2010-04-28 23:02:27 +00003932
John McCalle9cccd82010-06-16 08:42:20 +00003933 if (Result.isInvalid()) {
3934 Owned(Base);
3935 return ExprError();
3936 }
John McCall10eae182009-11-30 22:42:35 +00003937
John McCalle9cccd82010-06-16 08:42:20 +00003938 if (Result.get()) {
3939 // The only way a reference to a destructor can be used is to
3940 // immediately call it, which falls into this case. If the
3941 // next token is not a '(', produce a diagnostic and build the
3942 // call now.
3943 if (!HasTrailingLParen &&
3944 Id.getKind() == UnqualifiedId::IK_DestructorName)
John McCallb268a282010-08-23 23:25:46 +00003945 return DiagnoseDtorReference(NameInfo.getLoc(), Result.get());
John McCall10eae182009-11-30 22:42:35 +00003946
John McCalle9cccd82010-06-16 08:42:20 +00003947 return move(Result);
John McCall10eae182009-11-30 22:42:35 +00003948 }
3949
John McCallb268a282010-08-23 23:25:46 +00003950 Result = BuildMemberReferenceExpr(Base, Base->getType(),
John McCall38836f02010-01-15 08:34:02 +00003951 OpLoc, IsArrow, SS, FirstQualifierInScope,
3952 R, TemplateArgs);
John McCall10eae182009-11-30 22:42:35 +00003953 }
3954
3955 return move(Result);
Anders Carlssonf571c112009-08-26 18:25:21 +00003956}
3957
John McCalldadc5752010-08-24 06:29:42 +00003958ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
Nico Weber44887f62010-11-29 18:19:25 +00003959 FunctionDecl *FD,
3960 ParmVarDecl *Param) {
Anders Carlsson355933d2009-08-25 03:49:14 +00003961 if (Param->hasUnparsedDefaultArg()) {
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003962 Diag(CallLoc,
Nico Weberebd45a02010-11-30 04:44:33 +00003963 diag::err_use_of_default_argument_to_function_declared_later) <<
Anders Carlsson355933d2009-08-25 03:49:14 +00003964 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00003965 Diag(UnparsedDefaultArgLocs[Param],
Nico Weberebd45a02010-11-30 04:44:33 +00003966 diag::note_default_argument_declared_here);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003967 return ExprError();
3968 }
3969
3970 if (Param->hasUninstantiatedDefaultArg()) {
3971 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
Anders Carlsson355933d2009-08-25 03:49:14 +00003972
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003973 // Instantiate the expression.
3974 MultiLevelTemplateArgumentList ArgList
3975 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true);
Anders Carlsson657bad42009-09-05 05:14:19 +00003976
Nico Weber44887f62010-11-29 18:19:25 +00003977 std::pair<const TemplateArgument *, unsigned> Innermost
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003978 = ArgList.getInnermost();
3979 InstantiatingTemplate Inst(*this, CallLoc, Param, Innermost.first,
3980 Innermost.second);
Anders Carlsson355933d2009-08-25 03:49:14 +00003981
Nico Weber44887f62010-11-29 18:19:25 +00003982 ExprResult Result;
3983 {
3984 // C++ [dcl.fct.default]p5:
3985 // The names in the [default argument] expression are bound, and
3986 // the semantic constraints are checked, at the point where the
3987 // default argument expression appears.
Nico Weberebd45a02010-11-30 04:44:33 +00003988 ContextRAII SavedContext(*this, FD);
Nico Weber44887f62010-11-29 18:19:25 +00003989 Result = SubstExpr(UninstExpr, ArgList);
3990 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003991 if (Result.isInvalid())
3992 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00003993
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003994 // Check the expression as an initializer for the parameter.
3995 InitializedEntity Entity
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00003996 = InitializedEntity::InitializeParameter(Context, Param);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003997 InitializationKind Kind
3998 = InitializationKind::CreateCopy(Param->getLocation(),
3999 /*FIXME:EqualLoc*/UninstExpr->getSourceRange().getBegin());
4000 Expr *ResultE = Result.takeAs<Expr>();
Douglas Gregor25ab25f2009-12-23 18:19:08 +00004001
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00004002 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1);
4003 Result = InitSeq.Perform(*this, Entity, Kind,
4004 MultiExprArg(*this, &ResultE, 1));
4005 if (Result.isInvalid())
4006 return ExprError();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004007
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00004008 // Build the default argument expression.
4009 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param,
4010 Result.takeAs<Expr>()));
Anders Carlsson355933d2009-08-25 03:49:14 +00004011 }
4012
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00004013 // If the default expression creates temporaries, we need to
4014 // push them to the current stack of expression temporaries so they'll
4015 // be properly destroyed.
4016 // FIXME: We should really be rebuilding the default argument with new
4017 // bound temporaries; see the comment in PR5810.
Douglas Gregor6ed2fee2010-09-14 22:55:20 +00004018 for (unsigned i = 0, e = Param->getNumDefaultArgTemporaries(); i != e; ++i) {
4019 CXXTemporary *Temporary = Param->getDefaultArgTemporary(i);
4020 MarkDeclarationReferenced(Param->getDefaultArg()->getLocStart(),
4021 const_cast<CXXDestructorDecl*>(Temporary->getDestructor()));
4022 ExprTemporaries.push_back(Temporary);
4023 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00004024
4025 // We already type-checked the argument, so we know it works.
Douglas Gregor32b3de52010-09-11 23:32:50 +00004026 // Just mark all of the declarations in this potentially-evaluated expression
4027 // as being "referenced".
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00004028 MarkDeclarationsReferencedInExpr(Param->getDefaultArg());
Douglas Gregor033f6752009-12-23 23:03:06 +00004029 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param));
Anders Carlsson355933d2009-08-25 03:49:14 +00004030}
4031
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004032/// ConvertArgumentsForCall - Converts the arguments specified in
4033/// Args/NumArgs to the parameter types of the function FDecl with
4034/// function prototype Proto. Call is the call expression itself, and
4035/// Fn is the function expression. For a C++ member function, this
4036/// routine does not attempt to convert the object argument. Returns
4037/// true if the call is ill-formed.
Mike Stump4e1f26a2009-02-19 03:04:26 +00004038bool
4039Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004040 FunctionDecl *FDecl,
Douglas Gregordeaad8c2009-02-26 23:50:07 +00004041 const FunctionProtoType *Proto,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004042 Expr **Args, unsigned NumArgs,
4043 SourceLocation RParenLoc) {
Mike Stump4e1f26a2009-02-19 03:04:26 +00004044 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004045 // assignment, to the types of the corresponding parameter, ...
4046 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregorb6b99612009-01-23 21:30:56 +00004047 bool Invalid = false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004048
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004049 // If too few arguments are available (and we don't have default
4050 // arguments for the remaining parameters), don't make the call.
4051 if (NumArgs < NumArgsInProto) {
4052 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments())
4053 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args)
Alexis Huntc46382e2010-04-28 23:02:27 +00004054 << Fn->getType()->isBlockPointerType()
Eric Christopherabf1e182010-04-16 04:48:22 +00004055 << NumArgsInProto << NumArgs << Fn->getSourceRange();
Ted Kremenek5a201952009-02-07 01:47:29 +00004056 Call->setNumArgs(Context, NumArgsInProto);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004057 }
4058
4059 // If too many are passed and not variadic, error on the extras and drop
4060 // them.
4061 if (NumArgs > NumArgsInProto) {
4062 if (!Proto->isVariadic()) {
4063 Diag(Args[NumArgsInProto]->getLocStart(),
4064 diag::err_typecheck_call_too_many_args)
Alexis Huntc46382e2010-04-28 23:02:27 +00004065 << Fn->getType()->isBlockPointerType()
Eric Christopher2a5aaff2010-04-16 04:56:46 +00004066 << NumArgsInProto << NumArgs << Fn->getSourceRange()
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004067 << SourceRange(Args[NumArgsInProto]->getLocStart(),
4068 Args[NumArgs-1]->getLocEnd());
4069 // This deletes the extra arguments.
Ted Kremenek5a201952009-02-07 01:47:29 +00004070 Call->setNumArgs(Context, NumArgsInProto);
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004071 return true;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004072 }
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004073 }
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004074 llvm::SmallVector<Expr *, 8> AllArgs;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004075 VariadicCallType CallType =
Fariborz Jahanian6f2d25e2009-11-24 19:27:49 +00004076 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
4077 if (Fn->getType()->isBlockPointerType())
4078 CallType = VariadicBlock; // Block
4079 else if (isa<MemberExpr>(Fn))
4080 CallType = VariadicMethod;
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004081 Invalid = GatherArgumentsForCall(Call->getSourceRange().getBegin(), FDecl,
Fariborz Jahanian4fa66ce2009-11-24 21:37:28 +00004082 Proto, 0, Args, NumArgs, AllArgs, CallType);
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004083 if (Invalid)
4084 return true;
4085 unsigned TotalNumArgs = AllArgs.size();
4086 for (unsigned i = 0; i < TotalNumArgs; ++i)
4087 Call->setArg(i, AllArgs[i]);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004088
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004089 return false;
4090}
Mike Stump4e1f26a2009-02-19 03:04:26 +00004091
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004092bool Sema::GatherArgumentsForCall(SourceLocation CallLoc,
4093 FunctionDecl *FDecl,
4094 const FunctionProtoType *Proto,
4095 unsigned FirstProtoArg,
4096 Expr **Args, unsigned NumArgs,
4097 llvm::SmallVector<Expr *, 8> &AllArgs,
Fariborz Jahanian6f2d25e2009-11-24 19:27:49 +00004098 VariadicCallType CallType) {
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004099 unsigned NumArgsInProto = Proto->getNumArgs();
4100 unsigned NumArgsToCheck = NumArgs;
4101 bool Invalid = false;
4102 if (NumArgs != NumArgsInProto)
4103 // Use default arguments for missing arguments
4104 NumArgsToCheck = NumArgsInProto;
4105 unsigned ArgIx = 0;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004106 // Continue to check argument types (even if we have too few/many args).
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004107 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004108 QualType ProtoArgType = Proto->getArgType(i);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004109
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004110 Expr *Arg;
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004111 if (ArgIx < NumArgs) {
4112 Arg = Args[ArgIx++];
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004113
Eli Friedman3164fb12009-03-22 22:00:50 +00004114 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
4115 ProtoArgType,
Anders Carlssond624e162009-08-26 23:45:07 +00004116 PDiag(diag::err_call_incomplete_argument)
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004117 << Arg->getSourceRange()))
Eli Friedman3164fb12009-03-22 22:00:50 +00004118 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004119
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004120 // Pass the argument
4121 ParmVarDecl *Param = 0;
4122 if (FDecl && i < FDecl->getNumParams())
4123 Param = FDecl->getParamDecl(i);
Douglas Gregor96596c92009-12-22 07:24:36 +00004124
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004125 InitializedEntity Entity =
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00004126 Param? InitializedEntity::InitializeParameter(Context, Param)
4127 : InitializedEntity::InitializeParameter(Context, ProtoArgType);
John McCalldadc5752010-08-24 06:29:42 +00004128 ExprResult ArgE = PerformCopyInitialization(Entity,
John McCall34376a62010-12-04 03:47:34 +00004129 SourceLocation(),
4130 Owned(Arg));
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004131 if (ArgE.isInvalid())
4132 return true;
4133
4134 Arg = ArgE.takeAs<Expr>();
Anders Carlsson84613c42009-06-12 16:51:40 +00004135 } else {
Anders Carlssonc80a1272009-08-25 02:29:20 +00004136 ParmVarDecl *Param = FDecl->getParamDecl(i);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004137
John McCalldadc5752010-08-24 06:29:42 +00004138 ExprResult ArgExpr =
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004139 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
Anders Carlsson355933d2009-08-25 03:49:14 +00004140 if (ArgExpr.isInvalid())
4141 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004142
Anders Carlsson355933d2009-08-25 03:49:14 +00004143 Arg = ArgExpr.takeAs<Expr>();
Anders Carlsson84613c42009-06-12 16:51:40 +00004144 }
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004145 AllArgs.push_back(Arg);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004146 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004147
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004148 // If this is a variadic call, handle args passed through "...".
Fariborz Jahanian6f2d25e2009-11-24 19:27:49 +00004149 if (CallType != VariadicDoesNotApply) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004150 // Promote the arguments (C99 6.5.2.2p7).
Chris Lattnerbb53efb2010-05-16 04:01:30 +00004151 for (unsigned i = ArgIx; i != NumArgs; ++i) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004152 Expr *Arg = Args[i];
Chris Lattnerbb53efb2010-05-16 04:01:30 +00004153 Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType, FDecl);
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004154 AllArgs.push_back(Arg);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004155 }
4156 }
Douglas Gregorb6b99612009-01-23 21:30:56 +00004157 return Invalid;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004158}
4159
Steve Naroff83895f72007-09-16 03:34:24 +00004160/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Chris Lattnere168f762006-11-10 05:29:30 +00004161/// This provides the location of the left/right parens and a list of comma
4162/// locations.
John McCalldadc5752010-08-24 06:29:42 +00004163ExprResult
John McCallb268a282010-08-23 23:25:46 +00004164Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
Douglas Gregorce5aa332010-09-09 16:33:13 +00004165 MultiExprArg args, SourceLocation RParenLoc) {
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004166 unsigned NumArgs = args.size();
Nate Begeman5ec4b312009-08-10 23:49:36 +00004167
4168 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCalldadc5752010-08-24 06:29:42 +00004169 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn);
John McCallb268a282010-08-23 23:25:46 +00004170 if (Result.isInvalid()) return ExprError();
4171 Fn = Result.take();
Mike Stump11289f42009-09-09 15:08:12 +00004172
John McCallb268a282010-08-23 23:25:46 +00004173 Expr **Args = args.release();
Mike Stump11289f42009-09-09 15:08:12 +00004174
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004175 if (getLangOptions().CPlusPlus) {
Douglas Gregorad8a3362009-09-04 17:36:40 +00004176 // If this is a pseudo-destructor expression, build the call immediately.
4177 if (isa<CXXPseudoDestructorExpr>(Fn)) {
4178 if (NumArgs > 0) {
4179 // Pseudo-destructor calls should not have any arguments.
4180 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args)
Douglas Gregora771f462010-03-31 17:46:05 +00004181 << FixItHint::CreateRemoval(
Douglas Gregorad8a3362009-09-04 17:36:40 +00004182 SourceRange(Args[0]->getLocStart(),
4183 Args[NumArgs-1]->getLocEnd()));
Mike Stump11289f42009-09-09 15:08:12 +00004184
Douglas Gregorad8a3362009-09-04 17:36:40 +00004185 NumArgs = 0;
4186 }
Mike Stump11289f42009-09-09 15:08:12 +00004187
Douglas Gregorad8a3362009-09-04 17:36:40 +00004188 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy,
John McCall7decc9e2010-11-18 06:31:45 +00004189 VK_RValue, RParenLoc));
Douglas Gregorad8a3362009-09-04 17:36:40 +00004190 }
Mike Stump11289f42009-09-09 15:08:12 +00004191
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004192 // Determine whether this is a dependent call inside a C++ template,
Mike Stump4e1f26a2009-02-19 03:04:26 +00004193 // in which case we won't do any semantic analysis now.
Mike Stump87c57ac2009-05-16 07:39:55 +00004194 // FIXME: Will need to cache the results of name lookup (including ADL) in
4195 // Fn.
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004196 bool Dependent = false;
4197 if (Fn->isTypeDependent())
4198 Dependent = true;
4199 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs))
4200 Dependent = true;
4201
4202 if (Dependent)
Ted Kremenekd7b4f402009-02-09 20:51:47 +00004203 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs,
John McCall7decc9e2010-11-18 06:31:45 +00004204 Context.DependentTy, VK_RValue,
4205 RParenLoc));
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004206
4207 // Determine whether this is a call to an object (C++ [over.call.object]).
4208 if (Fn->getType()->isRecordType())
4209 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs,
Douglas Gregorce5aa332010-09-09 16:33:13 +00004210 RParenLoc));
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004211
John McCall10eae182009-11-30 22:42:35 +00004212 Expr *NakedFn = Fn->IgnoreParens();
4213
4214 // Determine whether this is a call to an unresolved member function.
4215 if (UnresolvedMemberExpr *MemE = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4216 // If lookup was unresolved but not dependent (i.e. didn't find
4217 // an unresolved using declaration), it has to be an overloaded
4218 // function set, which means it must contain either multiple
4219 // declarations (all methods or method templates) or a single
4220 // method template.
4221 assert((MemE->getNumDecls() > 1) ||
Douglas Gregor516d6722010-04-25 21:15:30 +00004222 isa<FunctionTemplateDecl>(
4223 (*MemE->decls_begin())->getUnderlyingDecl()));
Douglas Gregor8f184a32009-12-01 03:34:29 +00004224 (void)MemE;
John McCall10eae182009-11-30 22:42:35 +00004225
John McCall2d74de92009-12-01 22:10:20 +00004226 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
Douglas Gregorce5aa332010-09-09 16:33:13 +00004227 RParenLoc);
John McCall10eae182009-11-30 22:42:35 +00004228 }
4229
Douglas Gregore254f902009-02-04 00:32:51 +00004230 // Determine whether this is a call to a member function.
John McCall10eae182009-11-30 22:42:35 +00004231 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(NakedFn)) {
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00004232 NamedDecl *MemDecl = MemExpr->getMemberDecl();
John McCall10eae182009-11-30 22:42:35 +00004233 if (isa<CXXMethodDecl>(MemDecl))
John McCall2d74de92009-12-01 22:10:20 +00004234 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
Douglas Gregorce5aa332010-09-09 16:33:13 +00004235 RParenLoc);
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00004236 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004237
Anders Carlsson61914b52009-10-03 17:40:22 +00004238 // Determine whether this is a call to a pointer-to-member function.
John McCall10eae182009-11-30 22:42:35 +00004239 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(NakedFn)) {
John McCalle3027922010-08-25 11:45:40 +00004240 if (BO->getOpcode() == BO_PtrMemD ||
4241 BO->getOpcode() == BO_PtrMemI) {
Douglas Gregorc8be9522010-05-04 18:18:31 +00004242 if (const FunctionProtoType *FPT
4243 = BO->getType()->getAs<FunctionProtoType>()) {
Douglas Gregor603d81b2010-07-13 08:18:22 +00004244 QualType ResultTy = FPT->getCallResultType(Context);
John McCall7decc9e2010-11-18 06:31:45 +00004245 ExprValueKind VK = Expr::getValueKindForType(FPT->getResultType());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004246
John McCallb268a282010-08-23 23:25:46 +00004247 CXXMemberCallExpr *TheCall
Abramo Bagnara21e9d862010-12-03 21:39:42 +00004248 = new (Context) CXXMemberCallExpr(Context, Fn, Args,
John McCall7decc9e2010-11-18 06:31:45 +00004249 NumArgs, ResultTy, VK,
John McCallb268a282010-08-23 23:25:46 +00004250 RParenLoc);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004251
4252 if (CheckCallReturnType(FPT->getResultType(),
4253 BO->getRHS()->getSourceRange().getBegin(),
John McCallb268a282010-08-23 23:25:46 +00004254 TheCall, 0))
Fariborz Jahanian42f66632009-10-28 16:49:46 +00004255 return ExprError();
Anders Carlsson63dce022009-10-15 00:41:48 +00004256
John McCallb268a282010-08-23 23:25:46 +00004257 if (ConvertArgumentsForCall(TheCall, BO, 0, FPT, Args, NumArgs,
Fariborz Jahanian42f66632009-10-28 16:49:46 +00004258 RParenLoc))
4259 return ExprError();
Anders Carlsson61914b52009-10-03 17:40:22 +00004260
John McCallb268a282010-08-23 23:25:46 +00004261 return MaybeBindToTemporary(TheCall);
Fariborz Jahanian42f66632009-10-28 16:49:46 +00004262 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004263 return ExprError(Diag(Fn->getLocStart(),
Fariborz Jahanian42f66632009-10-28 16:49:46 +00004264 diag::err_typecheck_call_not_function)
4265 << Fn->getType() << Fn->getSourceRange());
Anders Carlsson61914b52009-10-03 17:40:22 +00004266 }
4267 }
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004268 }
4269
Douglas Gregore254f902009-02-04 00:32:51 +00004270 // If we're directly calling a function, get the appropriate declaration.
Mike Stump11289f42009-09-09 15:08:12 +00004271 // Also, in C++, keep track of whether we should perform argument-dependent
Douglas Gregor89026b52009-06-30 23:57:56 +00004272 // lookup and whether there were any explicitly-specified template arguments.
Mike Stump4e1f26a2009-02-19 03:04:26 +00004273
Eli Friedmane14b1992009-12-26 03:35:45 +00004274 Expr *NakedFn = Fn->IgnoreParens();
Douglas Gregor928479e2010-11-09 20:03:54 +00004275 if (isa<UnresolvedLookupExpr>(NakedFn)) {
4276 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(NakedFn);
4277 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs,
4278 RParenLoc);
4279 }
4280
John McCall57500772009-12-16 12:17:52 +00004281 NamedDecl *NDecl = 0;
Douglas Gregor59f16ed2010-10-25 20:48:33 +00004282 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn))
4283 if (UnOp->getOpcode() == UO_AddrOf)
4284 NakedFn = UnOp->getSubExpr()->IgnoreParens();
4285
John McCall57500772009-12-16 12:17:52 +00004286 if (isa<DeclRefExpr>(NakedFn))
4287 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl();
4288
John McCall2d74de92009-12-01 22:10:20 +00004289 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc);
4290}
4291
John McCall57500772009-12-16 12:17:52 +00004292/// BuildResolvedCallExpr - Build a call to a resolved expression,
4293/// i.e. an expression not of \p OverloadTy. The expression should
John McCall2d74de92009-12-01 22:10:20 +00004294/// unary-convert to an expression of function-pointer or
4295/// block-pointer type.
4296///
4297/// \param NDecl the declaration being called, if available
John McCalldadc5752010-08-24 06:29:42 +00004298ExprResult
John McCall2d74de92009-12-01 22:10:20 +00004299Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
4300 SourceLocation LParenLoc,
4301 Expr **Args, unsigned NumArgs,
4302 SourceLocation RParenLoc) {
4303 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
4304
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00004305 // Promote the function operand.
4306 UsualUnaryConversions(Fn);
4307
Chris Lattner08464942007-12-28 05:29:59 +00004308 // Make the call expr early, before semantic checks. This guarantees cleanup
4309 // of arguments and function on error.
John McCallb268a282010-08-23 23:25:46 +00004310 CallExpr *TheCall = new (Context) CallExpr(Context, Fn,
4311 Args, NumArgs,
4312 Context.BoolTy,
John McCall7decc9e2010-11-18 06:31:45 +00004313 VK_RValue,
John McCallb268a282010-08-23 23:25:46 +00004314 RParenLoc);
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004315
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004316 const FunctionType *FuncT;
4317 if (!Fn->getType()->isBlockPointerType()) {
4318 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
4319 // have type pointer to function".
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004320 const PointerType *PT = Fn->getType()->getAs<PointerType>();
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004321 if (PT == 0)
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004322 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4323 << Fn->getType() << Fn->getSourceRange());
John McCall9dd450b2009-09-21 23:43:11 +00004324 FuncT = PT->getPointeeType()->getAs<FunctionType>();
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004325 } else { // This is a block call.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004326 FuncT = Fn->getType()->getAs<BlockPointerType>()->getPointeeType()->
John McCall9dd450b2009-09-21 23:43:11 +00004327 getAs<FunctionType>();
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004328 }
Chris Lattner08464942007-12-28 05:29:59 +00004329 if (FuncT == 0)
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004330 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4331 << Fn->getType() << Fn->getSourceRange());
4332
Eli Friedman3164fb12009-03-22 22:00:50 +00004333 // Check for a valid return type
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004334 if (CheckCallReturnType(FuncT->getResultType(),
John McCallb268a282010-08-23 23:25:46 +00004335 Fn->getSourceRange().getBegin(), TheCall,
Anders Carlsson7f84ed92009-10-09 23:51:55 +00004336 FDecl))
Eli Friedman3164fb12009-03-22 22:00:50 +00004337 return ExprError();
4338
Chris Lattner08464942007-12-28 05:29:59 +00004339 // We know the result type of the call, set it.
Douglas Gregor603d81b2010-07-13 08:18:22 +00004340 TheCall->setType(FuncT->getCallResultType(Context));
John McCall7decc9e2010-11-18 06:31:45 +00004341 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType()));
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004342
Douglas Gregordeaad8c2009-02-26 23:50:07 +00004343 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
John McCallb268a282010-08-23 23:25:46 +00004344 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004345 RParenLoc))
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004346 return ExprError();
Chris Lattner08464942007-12-28 05:29:59 +00004347 } else {
Douglas Gregordeaad8c2009-02-26 23:50:07 +00004348 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004349
Douglas Gregord8e97de2009-04-02 15:37:10 +00004350 if (FDecl) {
4351 // Check if we have too few/too many template arguments, based
4352 // on our knowledge of the function definition.
4353 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00004354 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) {
Douglas Gregor8e09a722010-10-25 20:39:23 +00004355 const FunctionProtoType *Proto
4356 = Def->getType()->getAs<FunctionProtoType>();
4357 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size()))
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00004358 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
4359 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange();
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00004360 }
Douglas Gregor8e09a722010-10-25 20:39:23 +00004361
4362 // If the function we're calling isn't a function prototype, but we have
4363 // a function prototype from a prior declaratiom, use that prototype.
4364 if (!FDecl->hasPrototype())
4365 Proto = FDecl->getType()->getAs<FunctionProtoType>();
Douglas Gregord8e97de2009-04-02 15:37:10 +00004366 }
4367
Steve Naroff0b661582007-08-28 23:30:39 +00004368 // Promote the arguments (C99 6.5.2.2p6).
Chris Lattner08464942007-12-28 05:29:59 +00004369 for (unsigned i = 0; i != NumArgs; i++) {
4370 Expr *Arg = Args[i];
Douglas Gregor8e09a722010-10-25 20:39:23 +00004371
4372 if (Proto && i < Proto->getNumArgs()) {
Douglas Gregor8e09a722010-10-25 20:39:23 +00004373 InitializedEntity Entity
4374 = InitializedEntity::InitializeParameter(Context,
4375 Proto->getArgType(i));
4376 ExprResult ArgE = PerformCopyInitialization(Entity,
4377 SourceLocation(),
4378 Owned(Arg));
4379 if (ArgE.isInvalid())
4380 return true;
4381
4382 Arg = ArgE.takeAs<Expr>();
4383
4384 } else {
4385 DefaultArgumentPromotion(Arg);
Douglas Gregor8e09a722010-10-25 20:39:23 +00004386 }
4387
Douglas Gregor83025412010-10-26 05:45:40 +00004388 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
4389 Arg->getType(),
4390 PDiag(diag::err_call_incomplete_argument)
4391 << Arg->getSourceRange()))
4392 return ExprError();
4393
Chris Lattner08464942007-12-28 05:29:59 +00004394 TheCall->setArg(i, Arg);
Steve Naroff0b661582007-08-28 23:30:39 +00004395 }
Steve Naroffae4143e2007-04-26 20:39:23 +00004396 }
Chris Lattner08464942007-12-28 05:29:59 +00004397
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004398 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
4399 if (!Method->isStatic())
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004400 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
4401 << Fn->getSourceRange());
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004402
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +00004403 // Check for sentinels
4404 if (NDecl)
4405 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs);
Mike Stump11289f42009-09-09 15:08:12 +00004406
Chris Lattnerb87b1b32007-08-10 20:18:51 +00004407 // Do special checking on direct calls to functions.
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004408 if (FDecl) {
John McCallb268a282010-08-23 23:25:46 +00004409 if (CheckFunctionCall(FDecl, TheCall))
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004410 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00004411
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00004412 if (unsigned BuiltinID = FDecl->getBuiltinID())
4413 return CheckBuiltinFunctionCall(BuiltinID, TheCall);
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004414 } else if (NDecl) {
John McCallb268a282010-08-23 23:25:46 +00004415 if (CheckBlockCall(NDecl, TheCall))
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004416 return ExprError();
4417 }
Chris Lattnerb87b1b32007-08-10 20:18:51 +00004418
John McCallb268a282010-08-23 23:25:46 +00004419 return MaybeBindToTemporary(TheCall);
Chris Lattnere168f762006-11-10 05:29:30 +00004420}
4421
John McCalldadc5752010-08-24 06:29:42 +00004422ExprResult
John McCallba7bf592010-08-24 05:47:05 +00004423Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
John McCallb268a282010-08-23 23:25:46 +00004424 SourceLocation RParenLoc, Expr *InitExpr) {
Steve Naroff83895f72007-09-16 03:34:24 +00004425 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
Steve Naroff57eb2c52007-07-19 21:32:11 +00004426 // FIXME: put back this assert when initializers are worked out.
Steve Naroff83895f72007-09-16 03:34:24 +00004427 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
John McCalle15bbff2010-01-18 19:35:47 +00004428
4429 TypeSourceInfo *TInfo;
4430 QualType literalType = GetTypeFromParser(Ty, &TInfo);
4431 if (!TInfo)
4432 TInfo = Context.getTrivialTypeSourceInfo(literalType);
4433
John McCallb268a282010-08-23 23:25:46 +00004434 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
John McCalle15bbff2010-01-18 19:35:47 +00004435}
4436
John McCalldadc5752010-08-24 06:29:42 +00004437ExprResult
John McCalle15bbff2010-01-18 19:35:47 +00004438Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
John McCallb268a282010-08-23 23:25:46 +00004439 SourceLocation RParenLoc, Expr *literalExpr) {
John McCalle15bbff2010-01-18 19:35:47 +00004440 QualType literalType = TInfo->getType();
Anders Carlsson2c1ec6d2007-12-05 07:24:19 +00004441
Eli Friedman37a186d2008-05-20 05:22:08 +00004442 if (literalType->isArrayType()) {
Argyrios Kyrtzidis85663562010-11-08 19:14:19 +00004443 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType),
4444 PDiag(diag::err_illegal_decl_array_incomplete_type)
4445 << SourceRange(LParenLoc,
4446 literalExpr->getSourceRange().getEnd())))
4447 return ExprError();
Chris Lattner7adf0762008-08-04 07:31:14 +00004448 if (literalType->isVariableArrayType())
Sebastian Redlb5d49352009-01-19 22:31:54 +00004449 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
4450 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()));
Douglas Gregor1c37d9e2009-05-21 23:48:18 +00004451 } else if (!literalType->isDependentType() &&
4452 RequireCompleteType(LParenLoc, literalType,
Anders Carlssond624e162009-08-26 23:45:07 +00004453 PDiag(diag::err_typecheck_decl_incomplete_type)
Mike Stump11289f42009-09-09 15:08:12 +00004454 << SourceRange(LParenLoc,
Anders Carlssond624e162009-08-26 23:45:07 +00004455 literalExpr->getSourceRange().getEnd())))
Sebastian Redlb5d49352009-01-19 22:31:54 +00004456 return ExprError();
Eli Friedman37a186d2008-05-20 05:22:08 +00004457
Douglas Gregor85dabae2009-12-16 01:38:02 +00004458 InitializedEntity Entity
Douglas Gregor1b303932009-12-22 15:35:07 +00004459 = InitializedEntity::InitializeTemporary(literalType);
Douglas Gregor85dabae2009-12-16 01:38:02 +00004460 InitializationKind Kind
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004461 = InitializationKind::CreateCast(SourceRange(LParenLoc, RParenLoc),
Douglas Gregor85dabae2009-12-16 01:38:02 +00004462 /*IsCStyleCast=*/true);
Eli Friedmana553d4a2009-12-22 02:35:53 +00004463 InitializationSequence InitSeq(*this, Entity, Kind, &literalExpr, 1);
John McCalldadc5752010-08-24 06:29:42 +00004464 ExprResult Result = InitSeq.Perform(*this, Entity, Kind,
John McCall37ad5512010-08-23 06:44:23 +00004465 MultiExprArg(*this, &literalExpr, 1),
Eli Friedmana553d4a2009-12-22 02:35:53 +00004466 &literalType);
4467 if (Result.isInvalid())
Sebastian Redlb5d49352009-01-19 22:31:54 +00004468 return ExprError();
John McCallb268a282010-08-23 23:25:46 +00004469 literalExpr = Result.get();
Steve Naroffd32419d2008-01-14 18:19:28 +00004470
Chris Lattner79413952008-12-04 23:50:19 +00004471 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
Steve Naroffd32419d2008-01-14 18:19:28 +00004472 if (isFileScope) { // 6.5.2.5p3
Steve Naroff98f72032008-01-10 22:15:12 +00004473 if (CheckForConstantInitializer(literalExpr, literalType))
Sebastian Redlb5d49352009-01-19 22:31:54 +00004474 return ExprError();
Steve Naroff98f72032008-01-10 22:15:12 +00004475 }
Eli Friedmana553d4a2009-12-22 02:35:53 +00004476
John McCall7decc9e2010-11-18 06:31:45 +00004477 // In C, compound literals are l-values for some reason.
4478 ExprValueKind VK = getLangOptions().CPlusPlus ? VK_RValue : VK_LValue;
4479
John McCall5d7aa7f2010-01-19 22:33:45 +00004480 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
John McCall7decc9e2010-11-18 06:31:45 +00004481 VK, literalExpr, isFileScope));
Steve Narofffbd09832007-07-19 01:06:55 +00004482}
4483
John McCalldadc5752010-08-24 06:29:42 +00004484ExprResult
Sebastian Redlb5d49352009-01-19 22:31:54 +00004485Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist,
Sebastian Redlb5d49352009-01-19 22:31:54 +00004486 SourceLocation RBraceLoc) {
4487 unsigned NumInit = initlist.size();
John McCallb268a282010-08-23 23:25:46 +00004488 Expr **InitList = initlist.release();
Anders Carlsson4692db02007-08-31 04:56:16 +00004489
Steve Naroff30d242c2007-09-15 18:49:24 +00004490 // Semantic analysis for initializers is done by ActOnDeclarator() and
Mike Stump4e1f26a2009-02-19 03:04:26 +00004491 // CheckInitializer() - it requires knowledge of the object being intialized.
Sebastian Redlb5d49352009-01-19 22:31:54 +00004492
Ted Kremenekac034612010-04-13 23:39:13 +00004493 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList,
4494 NumInit, RBraceLoc);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00004495 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
Sebastian Redlb5d49352009-01-19 22:31:54 +00004496 return Owned(E);
Steve Narofffbd09832007-07-19 01:06:55 +00004497}
4498
John McCalld7646252010-11-14 08:17:51 +00004499/// Prepares for a scalar cast, performing all the necessary stages
4500/// except the final cast and returning the kind required.
4501static CastKind PrepareScalarCast(Sema &S, Expr *&Src, QualType DestTy) {
4502 // Both Src and Dest are scalar types, i.e. arithmetic or pointer.
4503 // Also, callers should have filtered out the invalid cases with
4504 // pointers. Everything else should be possible.
4505
Abramo Bagnarade85bd42010-12-28 09:13:41 +00004506 QualType SrcTy = S.Context.getCanonicalType(Src->getType());
4507 DestTy = S.Context.getCanonicalType(DestTy);
John McCalld7646252010-11-14 08:17:51 +00004508 if (S.Context.hasSameUnqualifiedType(SrcTy, DestTy))
John McCalle3027922010-08-25 11:45:40 +00004509 return CK_NoOp;
Anders Carlsson094c4592009-10-18 18:12:03 +00004510
John McCall8cb679e2010-11-15 09:13:47 +00004511 switch (SrcTy->getScalarTypeKind()) {
4512 case Type::STK_MemberPointer:
4513 llvm_unreachable("member pointer type in C");
4514
4515 case Type::STK_Pointer:
4516 switch (DestTy->getScalarTypeKind()) {
4517 case Type::STK_Pointer:
4518 return DestTy->isObjCObjectPointerType() ?
John McCalld7646252010-11-14 08:17:51 +00004519 CK_AnyPointerToObjCPointerCast :
4520 CK_BitCast;
John McCall8cb679e2010-11-15 09:13:47 +00004521 case Type::STK_Bool:
4522 return CK_PointerToBoolean;
4523 case Type::STK_Integral:
4524 return CK_PointerToIntegral;
4525 case Type::STK_Floating:
4526 case Type::STK_FloatingComplex:
4527 case Type::STK_IntegralComplex:
4528 case Type::STK_MemberPointer:
4529 llvm_unreachable("illegal cast from pointer");
4530 }
4531 break;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004532
John McCall8cb679e2010-11-15 09:13:47 +00004533 case Type::STK_Bool: // casting from bool is like casting from an integer
4534 case Type::STK_Integral:
4535 switch (DestTy->getScalarTypeKind()) {
4536 case Type::STK_Pointer:
John McCalld7646252010-11-14 08:17:51 +00004537 if (Src->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNull))
John McCalle84af4e2010-11-13 01:35:44 +00004538 return CK_NullToPointer;
John McCalle3027922010-08-25 11:45:40 +00004539 return CK_IntegralToPointer;
John McCall8cb679e2010-11-15 09:13:47 +00004540 case Type::STK_Bool:
4541 return CK_IntegralToBoolean;
4542 case Type::STK_Integral:
John McCalld7646252010-11-14 08:17:51 +00004543 return CK_IntegralCast;
John McCall8cb679e2010-11-15 09:13:47 +00004544 case Type::STK_Floating:
John McCalle3027922010-08-25 11:45:40 +00004545 return CK_IntegralToFloating;
John McCall8cb679e2010-11-15 09:13:47 +00004546 case Type::STK_IntegralComplex:
John McCallfcef3cf2010-12-14 17:51:41 +00004547 S.ImpCastExprToType(Src, cast<ComplexType>(DestTy)->getElementType(),
4548 CK_IntegralCast);
John McCalld7646252010-11-14 08:17:51 +00004549 return CK_IntegralRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004550 case Type::STK_FloatingComplex:
John McCalld7646252010-11-14 08:17:51 +00004551 S.ImpCastExprToType(Src, cast<ComplexType>(DestTy)->getElementType(),
4552 CK_IntegralToFloating);
4553 return CK_FloatingRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004554 case Type::STK_MemberPointer:
4555 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004556 }
4557 break;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004558
John McCall8cb679e2010-11-15 09:13:47 +00004559 case Type::STK_Floating:
4560 switch (DestTy->getScalarTypeKind()) {
4561 case Type::STK_Floating:
John McCalle3027922010-08-25 11:45:40 +00004562 return CK_FloatingCast;
John McCall8cb679e2010-11-15 09:13:47 +00004563 case Type::STK_Bool:
4564 return CK_FloatingToBoolean;
4565 case Type::STK_Integral:
John McCalle3027922010-08-25 11:45:40 +00004566 return CK_FloatingToIntegral;
John McCall8cb679e2010-11-15 09:13:47 +00004567 case Type::STK_FloatingComplex:
John McCallfcef3cf2010-12-14 17:51:41 +00004568 S.ImpCastExprToType(Src, cast<ComplexType>(DestTy)->getElementType(),
4569 CK_FloatingCast);
John McCalld7646252010-11-14 08:17:51 +00004570 return CK_FloatingRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004571 case Type::STK_IntegralComplex:
John McCalld7646252010-11-14 08:17:51 +00004572 S.ImpCastExprToType(Src, cast<ComplexType>(DestTy)->getElementType(),
4573 CK_FloatingToIntegral);
4574 return CK_IntegralRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004575 case Type::STK_Pointer:
4576 llvm_unreachable("valid float->pointer cast?");
4577 case Type::STK_MemberPointer:
4578 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004579 }
4580 break;
4581
John McCall8cb679e2010-11-15 09:13:47 +00004582 case Type::STK_FloatingComplex:
4583 switch (DestTy->getScalarTypeKind()) {
4584 case Type::STK_FloatingComplex:
John McCalld7646252010-11-14 08:17:51 +00004585 return CK_FloatingComplexCast;
John McCall8cb679e2010-11-15 09:13:47 +00004586 case Type::STK_IntegralComplex:
John McCalld7646252010-11-14 08:17:51 +00004587 return CK_FloatingComplexToIntegralComplex;
John McCallfcef3cf2010-12-14 17:51:41 +00004588 case Type::STK_Floating: {
4589 QualType ET = cast<ComplexType>(SrcTy)->getElementType();
4590 if (S.Context.hasSameType(ET, DestTy))
4591 return CK_FloatingComplexToReal;
4592 S.ImpCastExprToType(Src, ET, CK_FloatingComplexToReal);
4593 return CK_FloatingCast;
4594 }
John McCall8cb679e2010-11-15 09:13:47 +00004595 case Type::STK_Bool:
John McCalld7646252010-11-14 08:17:51 +00004596 return CK_FloatingComplexToBoolean;
John McCall8cb679e2010-11-15 09:13:47 +00004597 case Type::STK_Integral:
John McCalld7646252010-11-14 08:17:51 +00004598 S.ImpCastExprToType(Src, cast<ComplexType>(SrcTy)->getElementType(),
4599 CK_FloatingComplexToReal);
4600 return CK_FloatingToIntegral;
John McCall8cb679e2010-11-15 09:13:47 +00004601 case Type::STK_Pointer:
4602 llvm_unreachable("valid complex float->pointer cast?");
4603 case Type::STK_MemberPointer:
4604 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004605 }
4606 break;
4607
John McCall8cb679e2010-11-15 09:13:47 +00004608 case Type::STK_IntegralComplex:
4609 switch (DestTy->getScalarTypeKind()) {
4610 case Type::STK_FloatingComplex:
John McCalld7646252010-11-14 08:17:51 +00004611 return CK_IntegralComplexToFloatingComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004612 case Type::STK_IntegralComplex:
John McCalld7646252010-11-14 08:17:51 +00004613 return CK_IntegralComplexCast;
John McCallfcef3cf2010-12-14 17:51:41 +00004614 case Type::STK_Integral: {
4615 QualType ET = cast<ComplexType>(SrcTy)->getElementType();
4616 if (S.Context.hasSameType(ET, DestTy))
4617 return CK_IntegralComplexToReal;
4618 S.ImpCastExprToType(Src, ET, CK_IntegralComplexToReal);
4619 return CK_IntegralCast;
4620 }
John McCall8cb679e2010-11-15 09:13:47 +00004621 case Type::STK_Bool:
John McCalld7646252010-11-14 08:17:51 +00004622 return CK_IntegralComplexToBoolean;
John McCall8cb679e2010-11-15 09:13:47 +00004623 case Type::STK_Floating:
John McCalld7646252010-11-14 08:17:51 +00004624 S.ImpCastExprToType(Src, cast<ComplexType>(SrcTy)->getElementType(),
4625 CK_IntegralComplexToReal);
4626 return CK_IntegralToFloating;
John McCall8cb679e2010-11-15 09:13:47 +00004627 case Type::STK_Pointer:
4628 llvm_unreachable("valid complex int->pointer cast?");
4629 case Type::STK_MemberPointer:
4630 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004631 }
4632 break;
Anders Carlsson094c4592009-10-18 18:12:03 +00004633 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004634
John McCalld7646252010-11-14 08:17:51 +00004635 llvm_unreachable("Unhandled scalar cast");
4636 return CK_BitCast;
Anders Carlsson094c4592009-10-18 18:12:03 +00004637}
4638
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004639/// CheckCastTypes - Check type constraints for casting between types.
John McCall7decc9e2010-11-18 06:31:45 +00004640bool Sema::CheckCastTypes(SourceRange TyR, QualType castType,
4641 Expr *&castExpr, CastKind& Kind, ExprValueKind &VK,
4642 CXXCastPath &BasePath, bool FunctionalStyle) {
Sebastian Redl9f831db2009-07-25 15:41:38 +00004643 if (getLangOptions().CPlusPlus)
Douglas Gregor15417cf2010-11-03 00:35:38 +00004644 return CXXCheckCStyleCast(SourceRange(TyR.getBegin(),
4645 castExpr->getLocEnd()),
John McCall7decc9e2010-11-18 06:31:45 +00004646 castType, VK, castExpr, Kind, BasePath,
Anders Carlssona70cff62010-04-24 19:06:50 +00004647 FunctionalStyle);
Sebastian Redl9f831db2009-07-25 15:41:38 +00004648
John McCall7decc9e2010-11-18 06:31:45 +00004649 // We only support r-value casts in C.
4650 VK = VK_RValue;
4651
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004652 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
4653 // type needs to be scalar.
4654 if (castType->isVoidType()) {
John McCall34376a62010-12-04 03:47:34 +00004655 // We don't necessarily do lvalue-to-rvalue conversions on this.
4656 IgnoredValueConversions(castExpr);
4657
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004658 // Cast to void allows any expr type.
John McCalle3027922010-08-25 11:45:40 +00004659 Kind = CK_ToVoid;
Anders Carlssonef918ac2009-10-16 02:35:04 +00004660 return false;
4661 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004662
John McCall34376a62010-12-04 03:47:34 +00004663 DefaultFunctionArrayLvalueConversion(castExpr);
4664
Eli Friedmane98194d2010-07-17 20:43:49 +00004665 if (RequireCompleteType(TyR.getBegin(), castType,
4666 diag::err_typecheck_cast_to_incomplete))
4667 return true;
4668
Anders Carlssonef918ac2009-10-16 02:35:04 +00004669 if (!castType->isScalarType() && !castType->isVectorType()) {
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00004670 if (Context.hasSameUnqualifiedType(castType, castExpr->getType()) &&
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004671 (castType->isStructureType() || castType->isUnionType())) {
4672 // GCC struct/union extension: allow cast to self.
Eli Friedmanba961a92009-03-23 00:24:07 +00004673 // FIXME: Check that the cast destination type is complete.
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004674 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar)
4675 << castType << castExpr->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00004676 Kind = CK_NoOp;
Anders Carlsson525b76b2009-10-16 02:48:28 +00004677 return false;
4678 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004679
Anders Carlsson525b76b2009-10-16 02:48:28 +00004680 if (castType->isUnionType()) {
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004681 // GCC cast to union extension
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004682 RecordDecl *RD = castType->getAs<RecordType>()->getDecl();
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004683 RecordDecl::field_iterator Field, FieldEnd;
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004684 for (Field = RD->field_begin(), FieldEnd = RD->field_end();
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004685 Field != FieldEnd; ++Field) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004686 if (Context.hasSameUnqualifiedType(Field->getType(),
Abramo Bagnara5d3e7242010-10-07 21:20:44 +00004687 castExpr->getType()) &&
4688 !Field->isUnnamedBitfield()) {
Seo Sanghyeon39a3ebf2009-01-15 04:51:39 +00004689 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union)
4690 << castExpr->getSourceRange();
4691 break;
4692 }
4693 }
4694 if (Field == FieldEnd)
4695 return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type)
4696 << castExpr->getType() << castExpr->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00004697 Kind = CK_ToUnion;
Anders Carlsson525b76b2009-10-16 02:48:28 +00004698 return false;
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004699 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004700
Anders Carlsson525b76b2009-10-16 02:48:28 +00004701 // Reject any other conversions to non-scalar types.
4702 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar)
4703 << castType << castExpr->getSourceRange();
4704 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004705
John McCalld7646252010-11-14 08:17:51 +00004706 // The type we're casting to is known to be a scalar or vector.
4707
4708 // Require the operand to be a scalar or vector.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004709 if (!castExpr->getType()->isScalarType() &&
Anders Carlsson525b76b2009-10-16 02:48:28 +00004710 !castExpr->getType()->isVectorType()) {
Chris Lattner3b054132008-11-19 05:08:23 +00004711 return Diag(castExpr->getLocStart(),
4712 diag::err_typecheck_expect_scalar_operand)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004713 << castExpr->getType() << castExpr->getSourceRange();
Anders Carlsson525b76b2009-10-16 02:48:28 +00004714 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004715
4716 if (castType->isExtVectorType())
Anders Carlsson43d70f82009-10-16 05:23:41 +00004717 return CheckExtVectorCast(TyR, castType, castExpr, Kind);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004718
Anders Carlsson525b76b2009-10-16 02:48:28 +00004719 if (castType->isVectorType())
4720 return CheckVectorCast(TyR, castType, castExpr->getType(), Kind);
4721 if (castExpr->getType()->isVectorType())
4722 return CheckVectorCast(TyR, castExpr->getType(), castType, Kind);
4723
John McCalld7646252010-11-14 08:17:51 +00004724 // The source and target types are both scalars, i.e.
4725 // - arithmetic types (fundamental, enum, and complex)
4726 // - all kinds of pointers
4727 // Note that member pointers were filtered out with C++, above.
4728
Anders Carlsson43d70f82009-10-16 05:23:41 +00004729 if (isa<ObjCSelectorExpr>(castExpr))
4730 return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004731
John McCalld7646252010-11-14 08:17:51 +00004732 // If either type is a pointer, the other type has to be either an
4733 // integer or a pointer.
Anders Carlsson525b76b2009-10-16 02:48:28 +00004734 if (!castType->isArithmeticType()) {
Eli Friedmanf4e3ad62009-05-01 02:23:58 +00004735 QualType castExprType = castExpr->getType();
Douglas Gregor6972a622010-06-16 00:35:25 +00004736 if (!castExprType->isIntegralType(Context) &&
Douglas Gregorb90df602010-06-16 00:17:44 +00004737 castExprType->isArithmeticType())
Eli Friedmanf4e3ad62009-05-01 02:23:58 +00004738 return Diag(castExpr->getLocStart(),
4739 diag::err_cast_pointer_from_non_pointer_int)
4740 << castExprType << castExpr->getSourceRange();
4741 } else if (!castExpr->getType()->isArithmeticType()) {
Douglas Gregor6972a622010-06-16 00:35:25 +00004742 if (!castType->isIntegralType(Context) && castType->isArithmeticType())
Eli Friedmanf4e3ad62009-05-01 02:23:58 +00004743 return Diag(castExpr->getLocStart(),
4744 diag::err_cast_pointer_to_non_pointer_int)
4745 << castType << castExpr->getSourceRange();
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004746 }
Anders Carlsson094c4592009-10-18 18:12:03 +00004747
John McCalld7646252010-11-14 08:17:51 +00004748 Kind = PrepareScalarCast(*this, castExpr, castType);
John McCall2b5c1b22010-08-12 21:44:57 +00004749
John McCalld7646252010-11-14 08:17:51 +00004750 if (Kind == CK_BitCast)
John McCall2b5c1b22010-08-12 21:44:57 +00004751 CheckCastAlign(castExpr, castType, TyR);
4752
Argyrios Kyrtzidis2ade3902008-08-16 20:27:34 +00004753 return false;
4754}
4755
Anders Carlsson525b76b2009-10-16 02:48:28 +00004756bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
John McCalle3027922010-08-25 11:45:40 +00004757 CastKind &Kind) {
Anders Carlssonde71adf2007-11-27 05:51:55 +00004758 assert(VectorTy->isVectorType() && "Not a vector type!");
Mike Stump4e1f26a2009-02-19 03:04:26 +00004759
Anders Carlssonde71adf2007-11-27 05:51:55 +00004760 if (Ty->isVectorType() || Ty->isIntegerType()) {
Chris Lattner37e05872008-03-05 18:54:05 +00004761 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
Anders Carlssonde71adf2007-11-27 05:51:55 +00004762 return Diag(R.getBegin(),
Mike Stump4e1f26a2009-02-19 03:04:26 +00004763 Ty->isVectorType() ?
Anders Carlssonde71adf2007-11-27 05:51:55 +00004764 diag::err_invalid_conversion_between_vectors :
Chris Lattner3b054132008-11-19 05:08:23 +00004765 diag::err_invalid_conversion_between_vector_and_integer)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004766 << VectorTy << Ty << R;
Anders Carlssonde71adf2007-11-27 05:51:55 +00004767 } else
4768 return Diag(R.getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +00004769 diag::err_invalid_conversion_between_vector_and_scalar)
Chris Lattner1e5665e2008-11-24 06:25:27 +00004770 << VectorTy << Ty << R;
Mike Stump4e1f26a2009-02-19 03:04:26 +00004771
John McCalle3027922010-08-25 11:45:40 +00004772 Kind = CK_BitCast;
Anders Carlssonde71adf2007-11-27 05:51:55 +00004773 return false;
4774}
4775
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004776bool Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *&CastExpr,
John McCalle3027922010-08-25 11:45:40 +00004777 CastKind &Kind) {
Nate Begemanc69b7402009-06-26 00:50:28 +00004778 assert(DestTy->isExtVectorType() && "Not an extended vector type!");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004779
Anders Carlsson43d70f82009-10-16 05:23:41 +00004780 QualType SrcTy = CastExpr->getType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004781
Nate Begemanc8961a42009-06-27 22:05:55 +00004782 // If SrcTy is a VectorType, the total size must match to explicitly cast to
4783 // an ExtVectorType.
Nate Begemanc69b7402009-06-26 00:50:28 +00004784 if (SrcTy->isVectorType()) {
4785 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy))
4786 return Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
4787 << DestTy << SrcTy << R;
John McCalle3027922010-08-25 11:45:40 +00004788 Kind = CK_BitCast;
Nate Begemanc69b7402009-06-26 00:50:28 +00004789 return false;
4790 }
4791
Nate Begemanbd956c42009-06-28 02:36:38 +00004792 // All non-pointer scalars can be cast to ExtVector type. The appropriate
Nate Begemanc69b7402009-06-26 00:50:28 +00004793 // conversion will take place first from scalar to elt type, and then
4794 // splat from elt type to vector.
Nate Begemanbd956c42009-06-28 02:36:38 +00004795 if (SrcTy->isPointerType())
4796 return Diag(R.getBegin(),
4797 diag::err_invalid_conversion_between_vector_and_scalar)
4798 << DestTy << SrcTy << R;
Eli Friedman06ed2a52009-10-20 08:27:19 +00004799
4800 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType();
4801 ImpCastExprToType(CastExpr, DestElemTy,
John McCalld7646252010-11-14 08:17:51 +00004802 PrepareScalarCast(*this, CastExpr, DestElemTy));
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004803
John McCalle3027922010-08-25 11:45:40 +00004804 Kind = CK_VectorSplat;
Nate Begemanc69b7402009-06-26 00:50:28 +00004805 return false;
4806}
4807
John McCalldadc5752010-08-24 06:29:42 +00004808ExprResult
John McCallba7bf592010-08-24 05:47:05 +00004809Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, ParsedType Ty,
John McCallb268a282010-08-23 23:25:46 +00004810 SourceLocation RParenLoc, Expr *castExpr) {
4811 assert((Ty != 0) && (castExpr != 0) &&
Sebastian Redlb5d49352009-01-19 22:31:54 +00004812 "ActOnCastExpr(): missing type or expr");
Steve Naroff1a2cf6b2007-07-16 23:25:18 +00004813
John McCall97513962010-01-15 18:39:57 +00004814 TypeSourceInfo *castTInfo;
4815 QualType castType = GetTypeFromParser(Ty, &castTInfo);
4816 if (!castTInfo)
John McCalle15bbff2010-01-18 19:35:47 +00004817 castTInfo = Context.getTrivialTypeSourceInfo(castType);
Mike Stump11289f42009-09-09 15:08:12 +00004818
Nate Begeman5ec4b312009-08-10 23:49:36 +00004819 // If the Expr being casted is a ParenListExpr, handle it specially.
4820 if (isa<ParenListExpr>(castExpr))
John McCallb268a282010-08-23 23:25:46 +00004821 return ActOnCastOfParenListExpr(S, LParenLoc, RParenLoc, castExpr,
John McCalle15bbff2010-01-18 19:35:47 +00004822 castTInfo);
John McCallebe54742010-01-15 18:56:44 +00004823
John McCallb268a282010-08-23 23:25:46 +00004824 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, castExpr);
John McCallebe54742010-01-15 18:56:44 +00004825}
4826
John McCalldadc5752010-08-24 06:29:42 +00004827ExprResult
John McCallebe54742010-01-15 18:56:44 +00004828Sema::BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty,
John McCallb268a282010-08-23 23:25:46 +00004829 SourceLocation RParenLoc, Expr *castExpr) {
John McCall8cb679e2010-11-15 09:13:47 +00004830 CastKind Kind = CK_Invalid;
John McCall7decc9e2010-11-18 06:31:45 +00004831 ExprValueKind VK = VK_RValue;
John McCallcf142162010-08-07 06:22:56 +00004832 CXXCastPath BasePath;
John McCallebe54742010-01-15 18:56:44 +00004833 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), Ty->getType(), castExpr,
John McCall7decc9e2010-11-18 06:31:45 +00004834 Kind, VK, BasePath))
Sebastian Redlb5d49352009-01-19 22:31:54 +00004835 return ExprError();
Anders Carlssone9766d52009-09-09 21:33:21 +00004836
John McCallcf142162010-08-07 06:22:56 +00004837 return Owned(CStyleCastExpr::Create(Context,
Douglas Gregora8a089b2010-07-13 18:40:04 +00004838 Ty->getType().getNonLValueExprType(Context),
John McCall7decc9e2010-11-18 06:31:45 +00004839 VK, Kind, castExpr, &BasePath, Ty,
John McCallcf142162010-08-07 06:22:56 +00004840 LParenLoc, RParenLoc));
Chris Lattnere168f762006-11-10 05:29:30 +00004841}
4842
Nate Begeman5ec4b312009-08-10 23:49:36 +00004843/// This is not an AltiVec-style cast, so turn the ParenListExpr into a sequence
4844/// of comma binary operators.
John McCalldadc5752010-08-24 06:29:42 +00004845ExprResult
John McCallb268a282010-08-23 23:25:46 +00004846Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *expr) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00004847 ParenListExpr *E = dyn_cast<ParenListExpr>(expr);
4848 if (!E)
4849 return Owned(expr);
Mike Stump11289f42009-09-09 15:08:12 +00004850
John McCalldadc5752010-08-24 06:29:42 +00004851 ExprResult Result(E->getExpr(0));
Mike Stump11289f42009-09-09 15:08:12 +00004852
Nate Begeman5ec4b312009-08-10 23:49:36 +00004853 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
John McCallb268a282010-08-23 23:25:46 +00004854 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
4855 E->getExpr(i));
Mike Stump11289f42009-09-09 15:08:12 +00004856
John McCallb268a282010-08-23 23:25:46 +00004857 if (Result.isInvalid()) return ExprError();
4858
4859 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
Nate Begeman5ec4b312009-08-10 23:49:36 +00004860}
4861
John McCalldadc5752010-08-24 06:29:42 +00004862ExprResult
Nate Begeman5ec4b312009-08-10 23:49:36 +00004863Sema::ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
John McCallb268a282010-08-23 23:25:46 +00004864 SourceLocation RParenLoc, Expr *Op,
John McCalle15bbff2010-01-18 19:35:47 +00004865 TypeSourceInfo *TInfo) {
John McCallb268a282010-08-23 23:25:46 +00004866 ParenListExpr *PE = cast<ParenListExpr>(Op);
John McCalle15bbff2010-01-18 19:35:47 +00004867 QualType Ty = TInfo->getType();
John Thompson781ad172010-06-30 22:55:51 +00004868 bool isAltiVecLiteral = false;
Mike Stump11289f42009-09-09 15:08:12 +00004869
John Thompson781ad172010-06-30 22:55:51 +00004870 // Check for an altivec literal,
4871 // i.e. all the elements are integer constants.
Nate Begeman5ec4b312009-08-10 23:49:36 +00004872 if (getLangOptions().AltiVec && Ty->isVectorType()) {
4873 if (PE->getNumExprs() == 0) {
4874 Diag(PE->getExprLoc(), diag::err_altivec_empty_initializer);
4875 return ExprError();
4876 }
John Thompson781ad172010-06-30 22:55:51 +00004877 if (PE->getNumExprs() == 1) {
4878 if (!PE->getExpr(0)->getType()->isVectorType())
4879 isAltiVecLiteral = true;
4880 }
4881 else
4882 isAltiVecLiteral = true;
4883 }
Nate Begeman5ec4b312009-08-10 23:49:36 +00004884
John Thompson781ad172010-06-30 22:55:51 +00004885 // If this is an altivec initializer, '(' type ')' '(' init, ..., init ')'
4886 // then handle it as such.
4887 if (isAltiVecLiteral) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00004888 llvm::SmallVector<Expr *, 8> initExprs;
4889 for (unsigned i = 0, e = PE->getNumExprs(); i != e; ++i)
4890 initExprs.push_back(PE->getExpr(i));
4891
4892 // FIXME: This means that pretty-printing the final AST will produce curly
4893 // braces instead of the original commas.
Ted Kremenekac034612010-04-13 23:39:13 +00004894 InitListExpr *E = new (Context) InitListExpr(Context, LParenLoc,
4895 &initExprs[0],
Nate Begeman5ec4b312009-08-10 23:49:36 +00004896 initExprs.size(), RParenLoc);
4897 E->setType(Ty);
John McCallb268a282010-08-23 23:25:46 +00004898 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, E);
Nate Begeman5ec4b312009-08-10 23:49:36 +00004899 } else {
Mike Stump11289f42009-09-09 15:08:12 +00004900 // This is not an AltiVec-style cast, so turn the ParenListExpr into a
Nate Begeman5ec4b312009-08-10 23:49:36 +00004901 // sequence of BinOp comma operators.
John McCalldadc5752010-08-24 06:29:42 +00004902 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Op);
John McCallb268a282010-08-23 23:25:46 +00004903 if (Result.isInvalid()) return ExprError();
4904 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Result.take());
Nate Begeman5ec4b312009-08-10 23:49:36 +00004905 }
4906}
4907
John McCalldadc5752010-08-24 06:29:42 +00004908ExprResult Sema::ActOnParenOrParenListExpr(SourceLocation L,
Nate Begeman5ec4b312009-08-10 23:49:36 +00004909 SourceLocation R,
Fariborz Jahanian906d8712009-11-25 01:26:41 +00004910 MultiExprArg Val,
John McCallba7bf592010-08-24 05:47:05 +00004911 ParsedType TypeOfCast) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00004912 unsigned nexprs = Val.size();
4913 Expr **exprs = reinterpret_cast<Expr**>(Val.release());
Fariborz Jahanian906d8712009-11-25 01:26:41 +00004914 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list");
4915 Expr *expr;
4916 if (nexprs == 1 && TypeOfCast && !TypeIsVectorType(TypeOfCast))
4917 expr = new (Context) ParenExpr(L, R, exprs[0]);
4918 else
4919 expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R);
Nate Begeman5ec4b312009-08-10 23:49:36 +00004920 return Owned(expr);
4921}
4922
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00004923/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension.
4924/// In that case, lhs = cond.
Chris Lattner2c486602009-02-18 04:38:20 +00004925/// C99 6.5.15
4926QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
John McCall7decc9e2010-11-18 06:31:45 +00004927 Expr *&SAVE, ExprValueKind &VK,
John McCall4bc41ae2010-11-18 19:01:18 +00004928 ExprObjectKind &OK,
Chris Lattner2c486602009-02-18 04:38:20 +00004929 SourceLocation QuestionLoc) {
Douglas Gregor0124e9b2010-11-09 21:07:58 +00004930 // If both LHS and RHS are overloaded functions, try to resolve them.
4931 if (Context.hasSameType(LHS->getType(), RHS->getType()) &&
4932 LHS->getType()->isSpecificBuiltinType(BuiltinType::Overload)) {
4933 ExprResult LHSResult = CheckPlaceholderExpr(LHS, QuestionLoc);
4934 if (LHSResult.isInvalid())
4935 return QualType();
4936
4937 ExprResult RHSResult = CheckPlaceholderExpr(RHS, QuestionLoc);
4938 if (RHSResult.isInvalid())
4939 return QualType();
4940
4941 LHS = LHSResult.take();
4942 RHS = RHSResult.take();
4943 }
4944
Sebastian Redl1a99f442009-04-16 17:51:27 +00004945 // C++ is sufficiently different to merit its own checker.
4946 if (getLangOptions().CPlusPlus)
John McCall4bc41ae2010-11-18 19:01:18 +00004947 return CXXCheckConditionalOperands(Cond, LHS, RHS, SAVE,
4948 VK, OK, QuestionLoc);
John McCall7decc9e2010-11-18 06:31:45 +00004949
4950 VK = VK_RValue;
John McCall4bc41ae2010-11-18 19:01:18 +00004951 OK = OK_Ordinary;
Sebastian Redl1a99f442009-04-16 17:51:27 +00004952
Chris Lattner432cff52009-02-18 04:28:32 +00004953 UsualUnaryConversions(Cond);
Fariborz Jahanian2b1d88a2010-09-18 19:38:38 +00004954 if (SAVE) {
4955 SAVE = LHS = Cond;
4956 }
4957 else
4958 UsualUnaryConversions(LHS);
Chris Lattner432cff52009-02-18 04:28:32 +00004959 UsualUnaryConversions(RHS);
4960 QualType CondTy = Cond->getType();
4961 QualType LHSTy = LHS->getType();
4962 QualType RHSTy = RHS->getType();
Steve Naroff31090012007-07-16 21:54:35 +00004963
Steve Naroffa78fe7e2007-05-16 19:47:19 +00004964 // first, check the condition.
Sebastian Redl1a99f442009-04-16 17:51:27 +00004965 if (!CondTy->isScalarType()) { // C99 6.5.15p2
Nate Begemanabb5a732010-09-20 22:41:17 +00004966 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar.
4967 // Throw an error if its not either.
4968 if (getLangOptions().OpenCL) {
4969 if (!CondTy->isVectorType()) {
4970 Diag(Cond->getLocStart(),
4971 diag::err_typecheck_cond_expect_scalar_or_vector)
4972 << CondTy;
4973 return QualType();
4974 }
4975 }
4976 else {
4977 Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar)
4978 << CondTy;
4979 return QualType();
4980 }
Steve Naroffa78fe7e2007-05-16 19:47:19 +00004981 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00004982
Chris Lattnere2949f42008-01-06 22:42:25 +00004983 // Now check the two expressions.
Nate Begeman5ec4b312009-08-10 23:49:36 +00004984 if (LHSTy->isVectorType() || RHSTy->isVectorType())
4985 return CheckVectorOperands(QuestionLoc, LHS, RHS);
Douglas Gregor4619e432008-12-05 23:32:09 +00004986
Nate Begemanabb5a732010-09-20 22:41:17 +00004987 // OpenCL: If the condition is a vector, and both operands are scalar,
4988 // attempt to implicity convert them to the vector type to act like the
4989 // built in select.
4990 if (getLangOptions().OpenCL && CondTy->isVectorType()) {
4991 // Both operands should be of scalar type.
4992 if (!LHSTy->isScalarType()) {
4993 Diag(LHS->getLocStart(), diag::err_typecheck_cond_expect_scalar)
4994 << CondTy;
4995 return QualType();
4996 }
4997 if (!RHSTy->isScalarType()) {
4998 Diag(RHS->getLocStart(), diag::err_typecheck_cond_expect_scalar)
4999 << CondTy;
5000 return QualType();
5001 }
5002 // Implicity convert these scalars to the type of the condition.
5003 ImpCastExprToType(LHS, CondTy, CK_IntegralCast);
5004 ImpCastExprToType(RHS, CondTy, CK_IntegralCast);
5005 }
5006
Chris Lattnere2949f42008-01-06 22:42:25 +00005007 // If both operands have arithmetic type, do the usual arithmetic conversions
5008 // to find a common type: C99 6.5.15p3,5.
Chris Lattner432cff52009-02-18 04:28:32 +00005009 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
5010 UsualArithmeticConversions(LHS, RHS);
5011 return LHS->getType();
Steve Naroffdbd9e892007-07-17 00:58:39 +00005012 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005013
Chris Lattnere2949f42008-01-06 22:42:25 +00005014 // If both operands are the same structure or union type, the result is that
5015 // type.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005016 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3
5017 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
Chris Lattner2ab40a62007-11-26 01:40:58 +00005018 if (LHSRT->getDecl() == RHSRT->getDecl())
Mike Stump4e1f26a2009-02-19 03:04:26 +00005019 // "If both the operands have structure or union type, the result has
Chris Lattnere2949f42008-01-06 22:42:25 +00005020 // that type." This implies that CV qualifiers are dropped.
Chris Lattner432cff52009-02-18 04:28:32 +00005021 return LHSTy.getUnqualifiedType();
Eli Friedmanba961a92009-03-23 00:24:07 +00005022 // FIXME: Type of conditional expression must be complete in C mode.
Steve Naroffa78fe7e2007-05-16 19:47:19 +00005023 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005024
Chris Lattnere2949f42008-01-06 22:42:25 +00005025 // C99 6.5.15p5: "If both operands have void type, the result has void type."
Steve Naroffbf1516c2008-05-12 21:44:38 +00005026 // The following || allows only one side to be void (a GCC-ism).
Chris Lattner432cff52009-02-18 04:28:32 +00005027 if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
5028 if (!LHSTy->isVoidType())
5029 Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void)
5030 << RHS->getSourceRange();
5031 if (!RHSTy->isVoidType())
5032 Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void)
5033 << LHS->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00005034 ImpCastExprToType(LHS, Context.VoidTy, CK_ToVoid);
5035 ImpCastExprToType(RHS, Context.VoidTy, CK_ToVoid);
Eli Friedman3e1852f2008-06-04 19:47:51 +00005036 return Context.VoidTy;
Steve Naroffbf1516c2008-05-12 21:44:38 +00005037 }
Steve Naroff039ad3c2008-01-08 01:11:38 +00005038 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
5039 // the type of the other operand."
Steve Naroff6b712a72009-07-14 18:25:06 +00005040 if ((LHSTy->isAnyPointerType() || LHSTy->isBlockPointerType()) &&
Douglas Gregor56751b52009-09-25 04:25:58 +00005041 RHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman06ed2a52009-10-20 08:27:19 +00005042 // promote the null to a pointer.
John McCall8cb679e2010-11-15 09:13:47 +00005043 ImpCastExprToType(RHS, LHSTy, CK_NullToPointer);
Chris Lattner432cff52009-02-18 04:28:32 +00005044 return LHSTy;
Steve Naroff039ad3c2008-01-08 01:11:38 +00005045 }
Steve Naroff6b712a72009-07-14 18:25:06 +00005046 if ((RHSTy->isAnyPointerType() || RHSTy->isBlockPointerType()) &&
Douglas Gregor56751b52009-09-25 04:25:58 +00005047 LHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
John McCall8cb679e2010-11-15 09:13:47 +00005048 ImpCastExprToType(LHS, RHSTy, CK_NullToPointer);
Chris Lattner432cff52009-02-18 04:28:32 +00005049 return RHSTy;
Steve Naroff039ad3c2008-01-08 01:11:38 +00005050 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005051
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005052 // All objective-c pointer type analysis is done here.
5053 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS,
5054 QuestionLoc);
5055 if (!compositeType.isNull())
5056 return compositeType;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005057
5058
Steve Naroff05efa972009-07-01 14:36:47 +00005059 // Handle block pointer types.
5060 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
5061 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
5062 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
5063 QualType destType = Context.getPointerType(Context.VoidTy);
John McCalle3027922010-08-25 11:45:40 +00005064 ImpCastExprToType(LHS, destType, CK_BitCast);
5065 ImpCastExprToType(RHS, destType, CK_BitCast);
Steve Naroff05efa972009-07-01 14:36:47 +00005066 return destType;
5067 }
5068 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005069 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Steve Naroff05efa972009-07-01 14:36:47 +00005070 return QualType();
Mike Stump1b821b42009-05-07 03:14:14 +00005071 }
Steve Naroff05efa972009-07-01 14:36:47 +00005072 // We have 2 block pointer types.
5073 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
5074 // Two identical block pointer types are always compatible.
Mike Stump1b821b42009-05-07 03:14:14 +00005075 return LHSTy;
5076 }
Steve Naroff05efa972009-07-01 14:36:47 +00005077 // The block pointer types aren't identical, continue checking.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005078 QualType lhptee = LHSTy->getAs<BlockPointerType>()->getPointeeType();
5079 QualType rhptee = RHSTy->getAs<BlockPointerType>()->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005080
Steve Naroff05efa972009-07-01 14:36:47 +00005081 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
5082 rhptee.getUnqualifiedType())) {
Mike Stump1b821b42009-05-07 03:14:14 +00005083 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005084 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Mike Stump1b821b42009-05-07 03:14:14 +00005085 // In this situation, we assume void* type. No especially good
5086 // reason, but this is what gcc does, and we do have to pick
5087 // to get a consistent AST.
5088 QualType incompatTy = Context.getPointerType(Context.VoidTy);
John McCalle3027922010-08-25 11:45:40 +00005089 ImpCastExprToType(LHS, incompatTy, CK_BitCast);
5090 ImpCastExprToType(RHS, incompatTy, CK_BitCast);
Mike Stump1b821b42009-05-07 03:14:14 +00005091 return incompatTy;
Steve Naroffa78fe7e2007-05-16 19:47:19 +00005092 }
Steve Naroff05efa972009-07-01 14:36:47 +00005093 // The block pointer types are compatible.
John McCalle3027922010-08-25 11:45:40 +00005094 ImpCastExprToType(LHS, LHSTy, CK_BitCast);
5095 ImpCastExprToType(RHS, LHSTy, CK_BitCast);
Steve Naroffea4c7802009-04-08 17:05:15 +00005096 return LHSTy;
5097 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005098
Steve Naroff05efa972009-07-01 14:36:47 +00005099 // Check constraints for C object pointers types (C99 6.5.15p3,6).
5100 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
5101 // get the "pointed to" types
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005102 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
5103 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
Steve Naroff05efa972009-07-01 14:36:47 +00005104
5105 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
5106 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
5107 // Figure out necessary qualifiers (C99 6.5.15p6)
John McCall8ccfcb52009-09-24 19:53:00 +00005108 QualType destPointee
5109 = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
Steve Naroff05efa972009-07-01 14:36:47 +00005110 QualType destType = Context.getPointerType(destPointee);
Eli Friedman06ed2a52009-10-20 08:27:19 +00005111 // Add qualifiers if necessary.
John McCalle3027922010-08-25 11:45:40 +00005112 ImpCastExprToType(LHS, destType, CK_NoOp);
Eli Friedman06ed2a52009-10-20 08:27:19 +00005113 // Promote to void*.
John McCalle3027922010-08-25 11:45:40 +00005114 ImpCastExprToType(RHS, destType, CK_BitCast);
Steve Naroff05efa972009-07-01 14:36:47 +00005115 return destType;
5116 }
5117 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
John McCall8ccfcb52009-09-24 19:53:00 +00005118 QualType destPointee
5119 = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
Steve Naroff05efa972009-07-01 14:36:47 +00005120 QualType destType = Context.getPointerType(destPointee);
Eli Friedman06ed2a52009-10-20 08:27:19 +00005121 // Add qualifiers if necessary.
John McCalle3027922010-08-25 11:45:40 +00005122 ImpCastExprToType(RHS, destType, CK_NoOp);
Eli Friedman06ed2a52009-10-20 08:27:19 +00005123 // Promote to void*.
John McCalle3027922010-08-25 11:45:40 +00005124 ImpCastExprToType(LHS, destType, CK_BitCast);
Steve Naroff05efa972009-07-01 14:36:47 +00005125 return destType;
5126 }
5127
5128 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
5129 // Two identical pointer types are always compatible.
5130 return LHSTy;
5131 }
5132 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
5133 rhptee.getUnqualifiedType())) {
5134 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
5135 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
5136 // In this situation, we assume void* type. No especially good
5137 // reason, but this is what gcc does, and we do have to pick
5138 // to get a consistent AST.
5139 QualType incompatTy = Context.getPointerType(Context.VoidTy);
John McCalle3027922010-08-25 11:45:40 +00005140 ImpCastExprToType(LHS, incompatTy, CK_BitCast);
5141 ImpCastExprToType(RHS, incompatTy, CK_BitCast);
Steve Naroff05efa972009-07-01 14:36:47 +00005142 return incompatTy;
5143 }
5144 // The pointer types are compatible.
5145 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
5146 // differently qualified versions of compatible types, the result type is
5147 // a pointer to an appropriately qualified version of the *composite*
5148 // type.
5149 // FIXME: Need to calculate the composite type.
5150 // FIXME: Need to add qualifiers
John McCalle3027922010-08-25 11:45:40 +00005151 ImpCastExprToType(LHS, LHSTy, CK_BitCast);
5152 ImpCastExprToType(RHS, LHSTy, CK_BitCast);
Steve Naroff05efa972009-07-01 14:36:47 +00005153 return LHSTy;
5154 }
Mike Stump11289f42009-09-09 15:08:12 +00005155
John McCalle84af4e2010-11-13 01:35:44 +00005156 // GCC compatibility: soften pointer/integer mismatch. Note that
5157 // null pointers have been filtered out by this point.
Steve Naroff05efa972009-07-01 14:36:47 +00005158 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) {
5159 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
5160 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00005161 ImpCastExprToType(LHS, RHSTy, CK_IntegralToPointer);
Steve Naroff05efa972009-07-01 14:36:47 +00005162 return RHSTy;
5163 }
5164 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) {
5165 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
5166 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00005167 ImpCastExprToType(RHS, LHSTy, CK_IntegralToPointer);
Steve Naroff05efa972009-07-01 14:36:47 +00005168 return LHSTy;
5169 }
Daniel Dunbar484603b2008-09-11 23:12:46 +00005170
Chris Lattnere2949f42008-01-06 22:42:25 +00005171 // Otherwise, the operands are not compatible.
Chris Lattner432cff52009-02-18 04:28:32 +00005172 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5173 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Steve Naroffa78fe7e2007-05-16 19:47:19 +00005174 return QualType();
Steve Narofff8a28c52007-05-15 20:29:32 +00005175}
5176
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005177/// FindCompositeObjCPointerType - Helper method to find composite type of
5178/// two objective-c pointer types of the two input expressions.
5179QualType Sema::FindCompositeObjCPointerType(Expr *&LHS, Expr *&RHS,
5180 SourceLocation QuestionLoc) {
5181 QualType LHSTy = LHS->getType();
5182 QualType RHSTy = RHS->getType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005183
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005184 // Handle things like Class and struct objc_class*. Here we case the result
5185 // to the pseudo-builtin, because that will be implicitly cast back to the
5186 // redefinition type if an attempt is made to access its fields.
5187 if (LHSTy->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005188 (Context.hasSameType(RHSTy, Context.ObjCClassRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005189 ImpCastExprToType(RHS, LHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005190 return LHSTy;
5191 }
5192 if (RHSTy->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005193 (Context.hasSameType(LHSTy, Context.ObjCClassRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005194 ImpCastExprToType(LHS, RHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005195 return RHSTy;
5196 }
5197 // And the same for struct objc_object* / id
5198 if (LHSTy->isObjCIdType() &&
John McCall717d9b02010-12-10 11:01:00 +00005199 (Context.hasSameType(RHSTy, Context.ObjCIdRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005200 ImpCastExprToType(RHS, LHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005201 return LHSTy;
5202 }
5203 if (RHSTy->isObjCIdType() &&
John McCall717d9b02010-12-10 11:01:00 +00005204 (Context.hasSameType(LHSTy, Context.ObjCIdRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005205 ImpCastExprToType(LHS, RHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005206 return RHSTy;
5207 }
5208 // And the same for struct objc_selector* / SEL
5209 if (Context.isObjCSelType(LHSTy) &&
John McCall717d9b02010-12-10 11:01:00 +00005210 (Context.hasSameType(RHSTy, Context.ObjCSelRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005211 ImpCastExprToType(RHS, LHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005212 return LHSTy;
5213 }
5214 if (Context.isObjCSelType(RHSTy) &&
John McCall717d9b02010-12-10 11:01:00 +00005215 (Context.hasSameType(LHSTy, Context.ObjCSelRedefinitionType))) {
John McCalle3027922010-08-25 11:45:40 +00005216 ImpCastExprToType(LHS, RHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005217 return RHSTy;
5218 }
5219 // Check constraints for Objective-C object pointers types.
5220 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005221
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005222 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
5223 // Two identical object pointer types are always compatible.
5224 return LHSTy;
5225 }
5226 const ObjCObjectPointerType *LHSOPT = LHSTy->getAs<ObjCObjectPointerType>();
5227 const ObjCObjectPointerType *RHSOPT = RHSTy->getAs<ObjCObjectPointerType>();
5228 QualType compositeType = LHSTy;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005229
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005230 // If both operands are interfaces and either operand can be
5231 // assigned to the other, use that type as the composite
5232 // type. This allows
5233 // xxx ? (A*) a : (B*) b
5234 // where B is a subclass of A.
5235 //
5236 // Additionally, as for assignment, if either type is 'id'
5237 // allow silent coercion. Finally, if the types are
5238 // incompatible then make sure to use 'id' as the composite
5239 // type so the result is acceptable for sending messages to.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005240
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005241 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
5242 // It could return the composite type.
5243 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
5244 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
5245 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
5246 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
5247 } else if ((LHSTy->isObjCQualifiedIdType() ||
5248 RHSTy->isObjCQualifiedIdType()) &&
5249 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) {
5250 // Need to handle "id<xx>" explicitly.
5251 // GCC allows qualified id and any Objective-C type to devolve to
5252 // id. Currently localizing to here until clear this should be
5253 // part of ObjCQualifiedIdTypesAreCompatible.
5254 compositeType = Context.getObjCIdType();
5255 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
5256 compositeType = Context.getObjCIdType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005257 } else if (!(compositeType =
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005258 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull())
5259 ;
5260 else {
5261 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
5262 << LHSTy << RHSTy
5263 << LHS->getSourceRange() << RHS->getSourceRange();
5264 QualType incompatTy = Context.getObjCIdType();
John McCalle3027922010-08-25 11:45:40 +00005265 ImpCastExprToType(LHS, incompatTy, CK_BitCast);
5266 ImpCastExprToType(RHS, incompatTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005267 return incompatTy;
5268 }
5269 // The object pointer types are compatible.
John McCalle3027922010-08-25 11:45:40 +00005270 ImpCastExprToType(LHS, compositeType, CK_BitCast);
5271 ImpCastExprToType(RHS, compositeType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005272 return compositeType;
5273 }
5274 // Check Objective-C object pointer types and 'void *'
5275 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
5276 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
5277 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
5278 QualType destPointee
5279 = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
5280 QualType destType = Context.getPointerType(destPointee);
5281 // Add qualifiers if necessary.
John McCalle3027922010-08-25 11:45:40 +00005282 ImpCastExprToType(LHS, destType, CK_NoOp);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005283 // Promote to void*.
John McCalle3027922010-08-25 11:45:40 +00005284 ImpCastExprToType(RHS, destType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005285 return destType;
5286 }
5287 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
5288 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
5289 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
5290 QualType destPointee
5291 = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
5292 QualType destType = Context.getPointerType(destPointee);
5293 // Add qualifiers if necessary.
John McCalle3027922010-08-25 11:45:40 +00005294 ImpCastExprToType(RHS, destType, CK_NoOp);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005295 // Promote to void*.
John McCalle3027922010-08-25 11:45:40 +00005296 ImpCastExprToType(LHS, destType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005297 return destType;
5298 }
5299 return QualType();
5300}
5301
Steve Naroff83895f72007-09-16 03:34:24 +00005302/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Chris Lattnere168f762006-11-10 05:29:30 +00005303/// in the case of a the GNU conditional expr extension.
John McCalldadc5752010-08-24 06:29:42 +00005304ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
Sebastian Redlb5d49352009-01-19 22:31:54 +00005305 SourceLocation ColonLoc,
John McCallb268a282010-08-23 23:25:46 +00005306 Expr *CondExpr, Expr *LHSExpr,
5307 Expr *RHSExpr) {
Chris Lattner2ab40a62007-11-26 01:40:58 +00005308 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
5309 // was the condition.
5310 bool isLHSNull = LHSExpr == 0;
Fariborz Jahanianc6bf0bd2010-08-31 18:02:20 +00005311 Expr *SAVEExpr = 0;
5312 if (isLHSNull) {
5313 LHSExpr = SAVEExpr = CondExpr;
5314 }
Sebastian Redlb5d49352009-01-19 22:31:54 +00005315
John McCall7decc9e2010-11-18 06:31:45 +00005316 ExprValueKind VK = VK_RValue;
John McCall4bc41ae2010-11-18 19:01:18 +00005317 ExprObjectKind OK = OK_Ordinary;
Fariborz Jahanian2b1d88a2010-09-18 19:38:38 +00005318 QualType result = CheckConditionalOperands(CondExpr, LHSExpr, RHSExpr,
John McCall4bc41ae2010-11-18 19:01:18 +00005319 SAVEExpr, VK, OK, QuestionLoc);
Steve Narofff8a28c52007-05-15 20:29:32 +00005320 if (result.isNull())
Sebastian Redlb5d49352009-01-19 22:31:54 +00005321 return ExprError();
5322
Douglas Gregor7e112b02009-08-26 14:37:04 +00005323 return Owned(new (Context) ConditionalOperator(CondExpr, QuestionLoc,
Fariborz Jahanianc6bf0bd2010-08-31 18:02:20 +00005324 LHSExpr, ColonLoc,
5325 RHSExpr, SAVEExpr,
John McCall4bc41ae2010-11-18 19:01:18 +00005326 result, VK, OK));
Chris Lattnere168f762006-11-10 05:29:30 +00005327}
5328
Steve Naroff3f597292007-05-11 22:18:03 +00005329// CheckPointerTypesForAssignment - This is a very tricky routine (despite
Mike Stump4e1f26a2009-02-19 03:04:26 +00005330// being closely modeled after the C99 spec:-). The odd characteristic of this
Steve Naroff3f597292007-05-11 22:18:03 +00005331// routine is it effectively iqnores the qualifiers on the top level pointee.
5332// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
5333// FIXME: add a couple examples in this comment.
Mike Stump4e1f26a2009-02-19 03:04:26 +00005334Sema::AssignConvertType
Steve Naroff98cf3e92007-06-06 18:38:38 +00005335Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
Steve Naroff3f597292007-05-11 22:18:03 +00005336 QualType lhptee, rhptee;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005337
David Chisnall9f57c292009-08-17 16:35:33 +00005338 if ((lhsType->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005339 (Context.hasSameType(rhsType, Context.ObjCClassRedefinitionType))) ||
David Chisnall9f57c292009-08-17 16:35:33 +00005340 (rhsType->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005341 (Context.hasSameType(lhsType, Context.ObjCClassRedefinitionType)))) {
David Chisnall9f57c292009-08-17 16:35:33 +00005342 return Compatible;
5343 }
5344
Steve Naroff1f4d7272007-05-11 04:00:31 +00005345 // get the "pointed to" type (ignoring qualifiers at the top level)
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005346 lhptee = lhsType->getAs<PointerType>()->getPointeeType();
5347 rhptee = rhsType->getAs<PointerType>()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00005348
Steve Naroff1f4d7272007-05-11 04:00:31 +00005349 // make sure we operate on the canonical type
Chris Lattner574dee62008-07-26 22:17:49 +00005350 lhptee = Context.getCanonicalType(lhptee);
5351 rhptee = Context.getCanonicalType(rhptee);
Steve Naroff1f4d7272007-05-11 04:00:31 +00005352
Chris Lattner9bad62c2008-01-04 18:04:52 +00005353 AssignConvertType ConvTy = Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005354
5355 // C99 6.5.16.1p1: This following citation is common to constraints
5356 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
5357 // qualifiers of the type *pointed to* by the right;
Fariborz Jahanianece85822009-02-17 18:27:45 +00005358 // FIXME: Handle ExtQualType
Douglas Gregor9a657932008-10-21 23:43:52 +00005359 if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
Chris Lattner9bad62c2008-01-04 18:04:52 +00005360 ConvTy = CompatiblePointerDiscardsQualifiers;
Steve Naroff3f597292007-05-11 22:18:03 +00005361
Mike Stump4e1f26a2009-02-19 03:04:26 +00005362 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
5363 // incomplete type and the other is a pointer to a qualified or unqualified
Steve Naroff3f597292007-05-11 22:18:03 +00005364 // version of void...
Chris Lattner0a788432008-01-03 22:56:36 +00005365 if (lhptee->isVoidType()) {
Chris Lattnerb3a176d2008-04-02 06:59:01 +00005366 if (rhptee->isIncompleteOrObjectType())
Chris Lattner9bad62c2008-01-04 18:04:52 +00005367 return ConvTy;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005368
Chris Lattner0a788432008-01-03 22:56:36 +00005369 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerb3a176d2008-04-02 06:59:01 +00005370 assert(rhptee->isFunctionType());
5371 return FunctionVoidPointer;
Chris Lattner0a788432008-01-03 22:56:36 +00005372 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005373
Chris Lattner0a788432008-01-03 22:56:36 +00005374 if (rhptee->isVoidType()) {
Chris Lattnerb3a176d2008-04-02 06:59:01 +00005375 if (lhptee->isIncompleteOrObjectType())
Chris Lattner9bad62c2008-01-04 18:04:52 +00005376 return ConvTy;
Chris Lattner0a788432008-01-03 22:56:36 +00005377
5378 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerb3a176d2008-04-02 06:59:01 +00005379 assert(lhptee->isFunctionType());
5380 return FunctionVoidPointer;
Chris Lattner0a788432008-01-03 22:56:36 +00005381 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005382 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
Steve Naroff3f597292007-05-11 22:18:03 +00005383 // unqualified versions of compatible types, ...
Eli Friedman80160bd2009-03-22 23:59:44 +00005384 lhptee = lhptee.getUnqualifiedType();
5385 rhptee = rhptee.getUnqualifiedType();
5386 if (!Context.typesAreCompatible(lhptee, rhptee)) {
5387 // Check if the pointee types are compatible ignoring the sign.
5388 // We explicitly check for char so that we catch "char" vs
5389 // "unsigned char" on systems where "char" is unsigned.
Chris Lattnerec3a1562009-10-17 20:33:28 +00005390 if (lhptee->isCharType())
Eli Friedman80160bd2009-03-22 23:59:44 +00005391 lhptee = Context.UnsignedCharTy;
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00005392 else if (lhptee->hasSignedIntegerRepresentation())
Eli Friedman80160bd2009-03-22 23:59:44 +00005393 lhptee = Context.getCorrespondingUnsignedType(lhptee);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005394
Chris Lattnerec3a1562009-10-17 20:33:28 +00005395 if (rhptee->isCharType())
Eli Friedman80160bd2009-03-22 23:59:44 +00005396 rhptee = Context.UnsignedCharTy;
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00005397 else if (rhptee->hasSignedIntegerRepresentation())
Eli Friedman80160bd2009-03-22 23:59:44 +00005398 rhptee = Context.getCorrespondingUnsignedType(rhptee);
Chris Lattnerec3a1562009-10-17 20:33:28 +00005399
Eli Friedman80160bd2009-03-22 23:59:44 +00005400 if (lhptee == rhptee) {
5401 // Types are compatible ignoring the sign. Qualifier incompatibility
5402 // takes priority over sign incompatibility because the sign
5403 // warning can be disabled.
5404 if (ConvTy != Compatible)
5405 return ConvTy;
5406 return IncompatiblePointerSign;
5407 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005408
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00005409 // If we are a multi-level pointer, it's possible that our issue is simply
5410 // one of qualification - e.g. char ** -> const char ** is not allowed. If
5411 // the eventual target type is the same and the pointers have the same
5412 // level of indirection, this must be the issue.
5413 if (lhptee->isPointerType() && rhptee->isPointerType()) {
5414 do {
5415 lhptee = lhptee->getAs<PointerType>()->getPointeeType();
5416 rhptee = rhptee->getAs<PointerType>()->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005417
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00005418 lhptee = Context.getCanonicalType(lhptee);
5419 rhptee = Context.getCanonicalType(rhptee);
5420 } while (lhptee->isPointerType() && rhptee->isPointerType());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005421
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00005422 if (Context.hasSameUnqualifiedType(lhptee, rhptee))
Alexis Hunt6f3de502009-11-08 07:46:34 +00005423 return IncompatibleNestedPointerQualifiers;
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00005424 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005425
Eli Friedman80160bd2009-03-22 23:59:44 +00005426 // General pointer incompatibility takes priority over qualifiers.
Mike Stump11289f42009-09-09 15:08:12 +00005427 return IncompatiblePointer;
Eli Friedman80160bd2009-03-22 23:59:44 +00005428 }
Chris Lattner9bad62c2008-01-04 18:04:52 +00005429 return ConvTy;
Steve Naroff1f4d7272007-05-11 04:00:31 +00005430}
5431
Steve Naroff081c7422008-09-04 15:10:53 +00005432/// CheckBlockPointerTypesForAssignment - This routine determines whether two
5433/// block pointer types are compatible or whether a block and normal pointer
5434/// are compatible. It is more restrict than comparing two function pointer
5435// types.
Mike Stump4e1f26a2009-02-19 03:04:26 +00005436Sema::AssignConvertType
5437Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
Steve Naroff081c7422008-09-04 15:10:53 +00005438 QualType rhsType) {
5439 QualType lhptee, rhptee;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005440
Steve Naroff081c7422008-09-04 15:10:53 +00005441 // get the "pointed to" type (ignoring qualifiers at the top level)
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005442 lhptee = lhsType->getAs<BlockPointerType>()->getPointeeType();
5443 rhptee = rhsType->getAs<BlockPointerType>()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00005444
Steve Naroff081c7422008-09-04 15:10:53 +00005445 // make sure we operate on the canonical type
5446 lhptee = Context.getCanonicalType(lhptee);
5447 rhptee = Context.getCanonicalType(rhptee);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005448
Steve Naroff081c7422008-09-04 15:10:53 +00005449 AssignConvertType ConvTy = Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005450
Steve Naroff081c7422008-09-04 15:10:53 +00005451 // For blocks we enforce that qualifiers are identical.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00005452 if (lhptee.getLocalCVRQualifiers() != rhptee.getLocalCVRQualifiers())
Steve Naroff081c7422008-09-04 15:10:53 +00005453 ConvTy = CompatiblePointerDiscardsQualifiers;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005454
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00005455 if (!getLangOptions().CPlusPlus) {
5456 if (!Context.typesAreBlockPointerCompatible(lhsType, rhsType))
5457 return IncompatibleBlockPointer;
5458 }
5459 else if (!Context.typesAreCompatible(lhptee, rhptee))
Mike Stump4e1f26a2009-02-19 03:04:26 +00005460 return IncompatibleBlockPointer;
Steve Naroff081c7422008-09-04 15:10:53 +00005461 return ConvTy;
5462}
5463
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005464/// CheckObjCPointerTypesForAssignment - Compares two objective-c pointer types
5465/// for assignment compatibility.
5466Sema::AssignConvertType
5467Sema::CheckObjCPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00005468 if (lhsType->isObjCBuiltinType()) {
5469 // Class is not compatible with ObjC object pointers.
Fariborz Jahanian9b37b1d2010-03-24 21:00:27 +00005470 if (lhsType->isObjCClassType() && !rhsType->isObjCBuiltinType() &&
5471 !rhsType->isObjCQualifiedClassType())
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00005472 return IncompatiblePointer;
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005473 return Compatible;
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00005474 }
5475 if (rhsType->isObjCBuiltinType()) {
5476 // Class is not compatible with ObjC object pointers.
Fariborz Jahanian9b37b1d2010-03-24 21:00:27 +00005477 if (rhsType->isObjCClassType() && !lhsType->isObjCBuiltinType() &&
5478 !lhsType->isObjCQualifiedClassType())
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00005479 return IncompatiblePointer;
5480 return Compatible;
5481 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005482 QualType lhptee =
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005483 lhsType->getAs<ObjCObjectPointerType>()->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005484 QualType rhptee =
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005485 rhsType->getAs<ObjCObjectPointerType>()->getPointeeType();
5486 // make sure we operate on the canonical type
5487 lhptee = Context.getCanonicalType(lhptee);
5488 rhptee = Context.getCanonicalType(rhptee);
5489 if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
5490 return CompatiblePointerDiscardsQualifiers;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005491
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005492 if (Context.typesAreCompatible(lhsType, rhsType))
5493 return Compatible;
5494 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType())
5495 return IncompatibleObjCQualifiedId;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005496 return IncompatiblePointer;
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005497}
5498
John McCall29600e12010-11-16 02:32:08 +00005499Sema::AssignConvertType
5500Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
5501 // Fake up an opaque expression. We don't actually care about what
5502 // cast operations are required, so if CheckAssignmentConstraints
5503 // adds casts to this they'll be wasted, but fortunately that doesn't
5504 // usually happen on valid code.
5505 OpaqueValueExpr rhs(rhsType, VK_RValue);
5506 Expr *rhsPtr = &rhs;
5507 CastKind K = CK_Invalid;
5508
5509 return CheckAssignmentConstraints(lhsType, rhsPtr, K);
5510}
5511
Mike Stump4e1f26a2009-02-19 03:04:26 +00005512/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
5513/// has code to accommodate several GCC extensions when type checking
Steve Naroff17f76e02007-05-03 21:03:48 +00005514/// pointers. Here are some objectionable examples that GCC considers warnings:
5515///
5516/// int a, *pint;
5517/// short *pshort;
5518/// struct foo *pfoo;
5519///
5520/// pint = pshort; // warning: assignment from incompatible pointer type
5521/// a = pint; // warning: assignment makes integer from pointer without a cast
5522/// pint = a; // warning: assignment makes pointer from integer without a cast
5523/// pint = pfoo; // warning: assignment from incompatible pointer type
5524///
5525/// As a result, the code for dealing with pointers is more complex than the
Mike Stump4e1f26a2009-02-19 03:04:26 +00005526/// C99 spec dictates.
Steve Naroff17f76e02007-05-03 21:03:48 +00005527///
John McCall8cb679e2010-11-15 09:13:47 +00005528/// Sets 'Kind' for any result kind except Incompatible.
Chris Lattner9bad62c2008-01-04 18:04:52 +00005529Sema::AssignConvertType
John McCall29600e12010-11-16 02:32:08 +00005530Sema::CheckAssignmentConstraints(QualType lhsType, Expr *&rhs,
John McCall8cb679e2010-11-15 09:13:47 +00005531 CastKind &Kind) {
John McCall29600e12010-11-16 02:32:08 +00005532 QualType rhsType = rhs->getType();
5533
Chris Lattnera52c2f22008-01-04 23:18:45 +00005534 // Get canonical types. We're not formatting these types, just comparing
5535 // them.
Chris Lattner574dee62008-07-26 22:17:49 +00005536 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
5537 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
Eli Friedman3360d892008-05-30 18:07:22 +00005538
John McCall8cb679e2010-11-15 09:13:47 +00005539 if (lhsType == rhsType) {
5540 Kind = CK_NoOp;
Chris Lattnerf5c973d2008-01-07 17:51:46 +00005541 return Compatible; // Common case: fast path an exact match.
John McCall8cb679e2010-11-15 09:13:47 +00005542 }
Steve Naroff44fd8ff2007-07-24 21:46:40 +00005543
David Chisnall9f57c292009-08-17 16:35:33 +00005544 if ((lhsType->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005545 (Context.hasSameType(rhsType, Context.ObjCClassRedefinitionType))) ||
David Chisnall9f57c292009-08-17 16:35:33 +00005546 (rhsType->isObjCClassType() &&
John McCall717d9b02010-12-10 11:01:00 +00005547 (Context.hasSameType(lhsType, Context.ObjCClassRedefinitionType)))) {
John McCall8cb679e2010-11-15 09:13:47 +00005548 Kind = CK_BitCast;
5549 return Compatible;
David Chisnall9f57c292009-08-17 16:35:33 +00005550 }
5551
Douglas Gregor6b754842008-10-28 00:22:11 +00005552 // If the left-hand side is a reference type, then we are in a
5553 // (rare!) case where we've allowed the use of references in C,
5554 // e.g., as a parameter type in a built-in function. In this case,
5555 // just make sure that the type referenced is compatible with the
5556 // right-hand side type. The caller is responsible for adjusting
5557 // lhsType so that the resulting expression does not have reference
5558 // type.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005559 if (const ReferenceType *lhsTypeRef = lhsType->getAs<ReferenceType>()) {
John McCall8cb679e2010-11-15 09:13:47 +00005560 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType)) {
5561 Kind = CK_LValueBitCast;
Anders Carlsson24ebce62007-10-12 23:56:29 +00005562 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005563 }
Chris Lattnera52c2f22008-01-04 23:18:45 +00005564 return Incompatible;
Fariborz Jahaniana1e34202007-12-19 17:45:58 +00005565 }
Nate Begemanbd956c42009-06-28 02:36:38 +00005566 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
5567 // to the same ExtVector type.
5568 if (lhsType->isExtVectorType()) {
5569 if (rhsType->isExtVectorType())
John McCall8cb679e2010-11-15 09:13:47 +00005570 return Incompatible;
5571 if (rhsType->isArithmeticType()) {
John McCall29600e12010-11-16 02:32:08 +00005572 // CK_VectorSplat does T -> vector T, so first cast to the
5573 // element type.
5574 QualType elType = cast<ExtVectorType>(lhsType)->getElementType();
5575 if (elType != rhsType) {
5576 Kind = PrepareScalarCast(*this, rhs, elType);
5577 ImpCastExprToType(rhs, elType, Kind);
5578 }
5579 Kind = CK_VectorSplat;
Nate Begemanbd956c42009-06-28 02:36:38 +00005580 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005581 }
Nate Begemanbd956c42009-06-28 02:36:38 +00005582 }
Mike Stump11289f42009-09-09 15:08:12 +00005583
Nate Begeman191a6b12008-07-14 18:02:46 +00005584 if (lhsType->isVectorType() || rhsType->isVectorType()) {
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00005585 if (lhsType->isVectorType() && rhsType->isVectorType()) {
Bob Wilson01856f32010-12-02 00:25:15 +00005586 // Allow assignments of an AltiVec vector type to an equivalent GCC
5587 // vector type and vice versa
5588 if (Context.areCompatibleVectorTypes(lhsType, rhsType)) {
5589 Kind = CK_BitCast;
5590 return Compatible;
5591 }
5592
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00005593 // If we are allowing lax vector conversions, and LHS and RHS are both
5594 // vectors, the total size only needs to be the same. This is a bitcast;
5595 // no bits are changed but the result type is different.
5596 if (getLangOptions().LaxVectorConversions &&
John McCall8cb679e2010-11-15 09:13:47 +00005597 (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))) {
John McCall3065d042010-11-15 10:08:00 +00005598 Kind = CK_BitCast;
Anders Carlssondb5a9b62009-01-30 23:17:46 +00005599 return IncompatibleVectors;
John McCall8cb679e2010-11-15 09:13:47 +00005600 }
Chris Lattner881a2122008-01-04 23:32:24 +00005601 }
5602 return Incompatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005603 }
Eli Friedman3360d892008-05-30 18:07:22 +00005604
Douglas Gregorbea453a2010-05-23 21:53:47 +00005605 if (lhsType->isArithmeticType() && rhsType->isArithmeticType() &&
John McCall8cb679e2010-11-15 09:13:47 +00005606 !(getLangOptions().CPlusPlus && lhsType->isEnumeralType())) {
John McCall29600e12010-11-16 02:32:08 +00005607 Kind = PrepareScalarCast(*this, rhs, lhsType);
Steve Naroff98cf3e92007-06-06 18:38:38 +00005608 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005609 }
Eli Friedman3360d892008-05-30 18:07:22 +00005610
Chris Lattnerec646832008-04-07 06:49:41 +00005611 if (isa<PointerType>(lhsType)) {
John McCall8cb679e2010-11-15 09:13:47 +00005612 if (rhsType->isIntegerType()) {
5613 Kind = CK_IntegralToPointer; // FIXME: null?
Chris Lattner940cfeb2008-01-04 18:22:42 +00005614 return IntToPointer;
John McCall8cb679e2010-11-15 09:13:47 +00005615 }
Eli Friedman3360d892008-05-30 18:07:22 +00005616
John McCall8cb679e2010-11-15 09:13:47 +00005617 if (isa<PointerType>(rhsType)) {
5618 Kind = CK_BitCast;
Steve Naroff98cf3e92007-06-06 18:38:38 +00005619 return CheckPointerTypesForAssignment(lhsType, rhsType);
John McCall8cb679e2010-11-15 09:13:47 +00005620 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005621
Steve Naroffaccc4882009-07-20 17:56:53 +00005622 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005623 if (isa<ObjCObjectPointerType>(rhsType)) {
John McCall8cb679e2010-11-15 09:13:47 +00005624 Kind = CK_AnyPointerToObjCPointerCast;
Steve Naroffaccc4882009-07-20 17:56:53 +00005625 if (lhsType->isVoidPointerType()) // an exception to the rule.
5626 return Compatible;
5627 return IncompatiblePointer;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005628 }
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005629 if (rhsType->getAs<BlockPointerType>()) {
John McCall8cb679e2010-11-15 09:13:47 +00005630 if (lhsType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
5631 Kind = CK_BitCast;
Douglas Gregore7dd1452008-11-27 00:44:28 +00005632 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005633 }
Steve Naroff32d072c2008-09-29 18:10:17 +00005634
5635 // Treat block pointers as objects.
John McCall8cb679e2010-11-15 09:13:47 +00005636 if (getLangOptions().ObjC1 && lhsType->isObjCIdType()) {
5637 Kind = CK_AnyPointerToObjCPointerCast;
Steve Naroff32d072c2008-09-29 18:10:17 +00005638 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005639 }
Steve Naroff32d072c2008-09-29 18:10:17 +00005640 }
Steve Naroff081c7422008-09-04 15:10:53 +00005641 return Incompatible;
5642 }
5643
5644 if (isa<BlockPointerType>(lhsType)) {
John McCall8cb679e2010-11-15 09:13:47 +00005645 if (rhsType->isIntegerType()) {
5646 Kind = CK_IntegralToPointer; // FIXME: null
Eli Friedman8163b7a2009-02-25 04:20:42 +00005647 return IntToBlockPointer;
John McCall8cb679e2010-11-15 09:13:47 +00005648 }
5649
5650 Kind = CK_AnyPointerToObjCPointerCast;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005651
Steve Naroff32d072c2008-09-29 18:10:17 +00005652 // Treat block pointers as objects.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005653 if (getLangOptions().ObjC1 && rhsType->isObjCIdType())
Steve Naroff32d072c2008-09-29 18:10:17 +00005654 return Compatible;
5655
Steve Naroff081c7422008-09-04 15:10:53 +00005656 if (rhsType->isBlockPointerType())
5657 return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005658
John McCall8cb679e2010-11-15 09:13:47 +00005659 if (const PointerType *RHSPT = rhsType->getAs<PointerType>())
Steve Naroff081c7422008-09-04 15:10:53 +00005660 if (RHSPT->getPointeeType()->isVoidType())
Douglas Gregore7dd1452008-11-27 00:44:28 +00005661 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005662
Chris Lattnera52c2f22008-01-04 23:18:45 +00005663 return Incompatible;
5664 }
5665
Steve Naroff7cae42b2009-07-10 23:34:53 +00005666 if (isa<ObjCObjectPointerType>(lhsType)) {
John McCall8cb679e2010-11-15 09:13:47 +00005667 if (rhsType->isIntegerType()) {
5668 Kind = CK_IntegralToPointer; // FIXME: null
Steve Naroff7cae42b2009-07-10 23:34:53 +00005669 return IntToPointer;
John McCall8cb679e2010-11-15 09:13:47 +00005670 }
5671
5672 Kind = CK_BitCast;
Mike Stump11289f42009-09-09 15:08:12 +00005673
Steve Naroffaccc4882009-07-20 17:56:53 +00005674 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005675 if (isa<PointerType>(rhsType)) {
Steve Naroffaccc4882009-07-20 17:56:53 +00005676 if (rhsType->isVoidPointerType()) // an exception to the rule.
5677 return Compatible;
5678 return IncompatiblePointer;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005679 }
5680 if (rhsType->isObjCObjectPointerType()) {
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00005681 return CheckObjCPointerTypesForAssignment(lhsType, rhsType);
Steve Naroff7cae42b2009-07-10 23:34:53 +00005682 }
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005683 if (const PointerType *RHSPT = rhsType->getAs<PointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00005684 if (RHSPT->getPointeeType()->isVoidType())
5685 return Compatible;
5686 }
5687 // Treat block pointers as objects.
5688 if (rhsType->isBlockPointerType())
5689 return Compatible;
5690 return Incompatible;
5691 }
Chris Lattnerec646832008-04-07 06:49:41 +00005692 if (isa<PointerType>(rhsType)) {
Steve Naroff98cf3e92007-06-06 18:38:38 +00005693 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
John McCall8cb679e2010-11-15 09:13:47 +00005694 if (lhsType == Context.BoolTy) {
5695 Kind = CK_PointerToBoolean;
Eli Friedman3360d892008-05-30 18:07:22 +00005696 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005697 }
Eli Friedman3360d892008-05-30 18:07:22 +00005698
John McCall8cb679e2010-11-15 09:13:47 +00005699 if (lhsType->isIntegerType()) {
5700 Kind = CK_PointerToIntegral;
Chris Lattner940cfeb2008-01-04 18:22:42 +00005701 return PointerToInt;
John McCall8cb679e2010-11-15 09:13:47 +00005702 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005703
5704 if (isa<BlockPointerType>(lhsType) &&
John McCall8cb679e2010-11-15 09:13:47 +00005705 rhsType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
5706 Kind = CK_AnyPointerToBlockPointerCast;
Douglas Gregore7dd1452008-11-27 00:44:28 +00005707 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005708 }
Chris Lattnera52c2f22008-01-04 23:18:45 +00005709 return Incompatible;
Chris Lattnera52c2f22008-01-04 23:18:45 +00005710 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00005711 if (isa<ObjCObjectPointerType>(rhsType)) {
5712 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
John McCall8cb679e2010-11-15 09:13:47 +00005713 if (lhsType == Context.BoolTy) {
5714 Kind = CK_PointerToBoolean;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005715 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005716 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00005717
John McCall8cb679e2010-11-15 09:13:47 +00005718 if (lhsType->isIntegerType()) {
5719 Kind = CK_PointerToIntegral;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005720 return PointerToInt;
John McCall8cb679e2010-11-15 09:13:47 +00005721 }
5722
5723 Kind = CK_BitCast;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005724
Steve Naroffaccc4882009-07-20 17:56:53 +00005725 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005726 if (isa<PointerType>(lhsType)) {
Steve Naroffaccc4882009-07-20 17:56:53 +00005727 if (lhsType->isVoidPointerType()) // an exception to the rule.
5728 return Compatible;
5729 return IncompatiblePointer;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005730 }
5731 if (isa<BlockPointerType>(lhsType) &&
John McCall8cb679e2010-11-15 09:13:47 +00005732 rhsType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
5733 Kind = CK_AnyPointerToBlockPointerCast;
Steve Naroff7cae42b2009-07-10 23:34:53 +00005734 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005735 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00005736 return Incompatible;
5737 }
Eli Friedman3360d892008-05-30 18:07:22 +00005738
Chris Lattnera52c2f22008-01-04 23:18:45 +00005739 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
John McCall8cb679e2010-11-15 09:13:47 +00005740 if (Context.typesAreCompatible(lhsType, rhsType)) {
5741 Kind = CK_NoOp;
Steve Naroff98cf3e92007-06-06 18:38:38 +00005742 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00005743 }
Bill Wendling216423b2007-05-30 06:30:29 +00005744 }
Steve Naroff98cf3e92007-06-06 18:38:38 +00005745 return Incompatible;
Steve Naroff9eb24652007-05-02 21:58:15 +00005746}
5747
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005748/// \brief Constructs a transparent union from an expression that is
5749/// used to initialize the transparent union.
Mike Stump11289f42009-09-09 15:08:12 +00005750static void ConstructTransparentUnion(ASTContext &C, Expr *&E,
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005751 QualType UnionType, FieldDecl *Field) {
5752 // Build an initializer list that designates the appropriate member
5753 // of the transparent union.
Ted Kremenekac034612010-04-13 23:39:13 +00005754 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
Ted Kremenek013041e2010-02-19 01:50:18 +00005755 &E, 1,
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005756 SourceLocation());
5757 Initializer->setType(UnionType);
5758 Initializer->setInitializedFieldInUnion(Field);
5759
5760 // Build a compound literal constructing a value of the transparent
5761 // union type from this initializer list.
John McCalle15bbff2010-01-18 19:35:47 +00005762 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
John McCall5d7aa7f2010-01-19 22:33:45 +00005763 E = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
John McCall7decc9e2010-11-18 06:31:45 +00005764 VK_RValue, Initializer, false);
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005765}
5766
5767Sema::AssignConvertType
5768Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
5769 QualType FromType = rExpr->getType();
5770
Mike Stump11289f42009-09-09 15:08:12 +00005771 // If the ArgType is a Union type, we want to handle a potential
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005772 // transparent_union GCC extension.
5773 const RecordType *UT = ArgType->getAsUnionType();
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00005774 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005775 return Incompatible;
5776
5777 // The field to initialize within the transparent union.
5778 RecordDecl *UD = UT->getDecl();
5779 FieldDecl *InitField = 0;
5780 // It's compatible if the expression matches any of the fields.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00005781 for (RecordDecl::field_iterator it = UD->field_begin(),
5782 itend = UD->field_end();
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005783 it != itend; ++it) {
5784 if (it->getType()->isPointerType()) {
5785 // If the transparent union contains a pointer type, we allow:
5786 // 1) void pointer
5787 // 2) null pointer constant
5788 if (FromType->isPointerType())
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005789 if (FromType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
John McCalle3027922010-08-25 11:45:40 +00005790 ImpCastExprToType(rExpr, it->getType(), CK_BitCast);
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005791 InitField = *it;
5792 break;
5793 }
Mike Stump11289f42009-09-09 15:08:12 +00005794
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005795 if (rExpr->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00005796 Expr::NPC_ValueDependentIsNull)) {
John McCalle84af4e2010-11-13 01:35:44 +00005797 ImpCastExprToType(rExpr, it->getType(), CK_NullToPointer);
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005798 InitField = *it;
5799 break;
5800 }
5801 }
5802
John McCall29600e12010-11-16 02:32:08 +00005803 Expr *rhs = rExpr;
John McCall8cb679e2010-11-15 09:13:47 +00005804 CastKind Kind = CK_Invalid;
John McCall29600e12010-11-16 02:32:08 +00005805 if (CheckAssignmentConstraints(it->getType(), rhs, Kind)
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005806 == Compatible) {
John McCall29600e12010-11-16 02:32:08 +00005807 ImpCastExprToType(rhs, it->getType(), Kind);
5808 rExpr = rhs;
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005809 InitField = *it;
5810 break;
5811 }
5812 }
5813
5814 if (!InitField)
5815 return Incompatible;
5816
5817 ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
5818 return Compatible;
5819}
5820
Chris Lattner9bad62c2008-01-04 18:04:52 +00005821Sema::AssignConvertType
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00005822Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
Douglas Gregor9a657932008-10-21 23:43:52 +00005823 if (getLangOptions().CPlusPlus) {
5824 if (!lhsType->isRecordType()) {
5825 // C++ 5.17p3: If the left operand is not of class type, the
5826 // expression is implicitly converted (C++ 4) to the
5827 // cv-unqualified type of the left operand.
Douglas Gregor47d3f272008-12-19 17:40:08 +00005828 if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(),
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00005829 AA_Assigning))
Douglas Gregor9a657932008-10-21 23:43:52 +00005830 return Incompatible;
Chris Lattner0d5640c2009-04-12 09:02:39 +00005831 return Compatible;
Douglas Gregor9a657932008-10-21 23:43:52 +00005832 }
5833
5834 // FIXME: Currently, we fall through and treat C++ classes like C
5835 // structures.
John McCall34376a62010-12-04 03:47:34 +00005836 }
Douglas Gregor9a657932008-10-21 23:43:52 +00005837
Steve Naroff0ee0b0a2007-11-27 17:58:44 +00005838 // C99 6.5.16.1p1: the left operand is a pointer and the right is
5839 // a null pointer constant.
Mike Stump11289f42009-09-09 15:08:12 +00005840 if ((lhsType->isPointerType() ||
5841 lhsType->isObjCObjectPointerType() ||
Mike Stump4e1f26a2009-02-19 03:04:26 +00005842 lhsType->isBlockPointerType())
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005843 && rExpr->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00005844 Expr::NPC_ValueDependentIsNull)) {
John McCall8cb679e2010-11-15 09:13:47 +00005845 ImpCastExprToType(rExpr, lhsType, CK_NullToPointer);
Steve Naroff0ee0b0a2007-11-27 17:58:44 +00005846 return Compatible;
5847 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005848
Chris Lattnere6dcd502007-10-16 02:55:40 +00005849 // This check seems unnatural, however it is necessary to ensure the proper
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00005850 // conversion of functions/arrays. If the conversion were done for all
Douglas Gregora121b752009-11-03 16:56:39 +00005851 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
Nick Lewyckyef7c0ff2010-08-05 06:27:49 +00005852 // expressions that suppress this implicit conversion (&, sizeof).
Chris Lattnere6dcd502007-10-16 02:55:40 +00005853 //
Mike Stump4e1f26a2009-02-19 03:04:26 +00005854 // Suppress this for references: C++ 8.5.3p5.
Chris Lattnere6dcd502007-10-16 02:55:40 +00005855 if (!lhsType->isReferenceType())
Douglas Gregorb92a1562010-02-03 00:27:59 +00005856 DefaultFunctionArrayLvalueConversion(rExpr);
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00005857
John McCall8cb679e2010-11-15 09:13:47 +00005858 CastKind Kind = CK_Invalid;
Chris Lattner9bad62c2008-01-04 18:04:52 +00005859 Sema::AssignConvertType result =
John McCall29600e12010-11-16 02:32:08 +00005860 CheckAssignmentConstraints(lhsType, rExpr, Kind);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005861
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00005862 // C99 6.5.16.1p2: The value of the right operand is converted to the
5863 // type of the assignment expression.
Douglas Gregor6b754842008-10-28 00:22:11 +00005864 // CheckAssignmentConstraints allows the left-hand side to be a reference,
5865 // so that we can use references in built-in functions even in C.
5866 // The getNonReferenceType() call makes sure that the resulting expression
5867 // does not have reference type.
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00005868 if (result != Incompatible && rExpr->getType() != lhsType)
John McCall8cb679e2010-11-15 09:13:47 +00005869 ImpCastExprToType(rExpr, lhsType.getNonLValueExprType(Context), Kind);
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00005870 return result;
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00005871}
5872
Chris Lattner326f7572008-11-18 01:30:42 +00005873QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
Chris Lattner377d1f82008-11-18 22:52:51 +00005874 Diag(Loc, diag::err_typecheck_invalid_operands)
Chris Lattner6a2ed6f2008-11-23 09:13:29 +00005875 << lex->getType() << rex->getType()
Chris Lattner377d1f82008-11-18 22:52:51 +00005876 << lex->getSourceRange() << rex->getSourceRange();
Chris Lattner5c11c412007-12-12 05:47:28 +00005877 return QualType();
Steve Naroff6f49f5d2007-05-29 14:23:36 +00005878}
5879
Chris Lattnerfaa54172010-01-12 21:23:57 +00005880QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
Mike Stump4e1f26a2009-02-19 03:04:26 +00005881 // For conversion purposes, we ignore any qualifiers.
Nate Begeman002e4bd2008-04-04 01:30:25 +00005882 // For example, "const float" and "float" are equivalent.
Chris Lattner574dee62008-07-26 22:17:49 +00005883 QualType lhsType =
5884 Context.getCanonicalType(lex->getType()).getUnqualifiedType();
5885 QualType rhsType =
5886 Context.getCanonicalType(rex->getType()).getUnqualifiedType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00005887
Nate Begeman191a6b12008-07-14 18:02:46 +00005888 // If the vector types are identical, return.
Nate Begeman002e4bd2008-04-04 01:30:25 +00005889 if (lhsType == rhsType)
Steve Naroff84ff4b42007-07-09 21:31:10 +00005890 return lhsType;
Nate Begeman330aaa72007-12-30 02:59:45 +00005891
Nate Begeman191a6b12008-07-14 18:02:46 +00005892 // Handle the case of a vector & extvector type of the same size and element
5893 // type. It would be nice if we only had one vector type someday.
Anders Carlssondb5a9b62009-01-30 23:17:46 +00005894 if (getLangOptions().LaxVectorConversions) {
John McCall9dd450b2009-09-21 23:43:11 +00005895 if (const VectorType *LV = lhsType->getAs<VectorType>()) {
Chandler Carruth9ed87ba2010-08-30 07:36:24 +00005896 if (const VectorType *RV = rhsType->getAs<VectorType>()) {
Nate Begeman191a6b12008-07-14 18:02:46 +00005897 if (LV->getElementType() == RV->getElementType() &&
Anders Carlssondb5a9b62009-01-30 23:17:46 +00005898 LV->getNumElements() == RV->getNumElements()) {
Douglas Gregorcbfbca12010-05-19 03:21:00 +00005899 if (lhsType->isExtVectorType()) {
John McCalle3027922010-08-25 11:45:40 +00005900 ImpCastExprToType(rex, lhsType, CK_BitCast);
Douglas Gregorcbfbca12010-05-19 03:21:00 +00005901 return lhsType;
5902 }
5903
John McCalle3027922010-08-25 11:45:40 +00005904 ImpCastExprToType(lex, rhsType, CK_BitCast);
Douglas Gregorcbfbca12010-05-19 03:21:00 +00005905 return rhsType;
Eric Christophera613f562010-08-26 00:42:16 +00005906 } else if (Context.getTypeSize(lhsType) ==Context.getTypeSize(rhsType)){
5907 // If we are allowing lax vector conversions, and LHS and RHS are both
5908 // vectors, the total size only needs to be the same. This is a
5909 // bitcast; no bits are changed but the result type is different.
5910 ImpCastExprToType(rex, lhsType, CK_BitCast);
5911 return lhsType;
Anders Carlssondb5a9b62009-01-30 23:17:46 +00005912 }
Eric Christophera613f562010-08-26 00:42:16 +00005913 }
Chandler Carruth9ed87ba2010-08-30 07:36:24 +00005914 }
Anders Carlssondb5a9b62009-01-30 23:17:46 +00005915 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005916
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00005917 // Handle the case of equivalent AltiVec and GCC vector types
5918 if (lhsType->isVectorType() && rhsType->isVectorType() &&
5919 Context.areCompatibleVectorTypes(lhsType, rhsType)) {
John McCalle3027922010-08-25 11:45:40 +00005920 ImpCastExprToType(lex, rhsType, CK_BitCast);
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00005921 return rhsType;
5922 }
5923
Nate Begemanbd956c42009-06-28 02:36:38 +00005924 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can
5925 // swap back (so that we don't reverse the inputs to a subtract, for instance.
5926 bool swapped = false;
5927 if (rhsType->isExtVectorType()) {
5928 swapped = true;
5929 std::swap(rex, lex);
5930 std::swap(rhsType, lhsType);
5931 }
Mike Stump11289f42009-09-09 15:08:12 +00005932
Nate Begeman886448d2009-06-28 19:12:57 +00005933 // Handle the case of an ext vector and scalar.
John McCall9dd450b2009-09-21 23:43:11 +00005934 if (const ExtVectorType *LV = lhsType->getAs<ExtVectorType>()) {
Nate Begemanbd956c42009-06-28 02:36:38 +00005935 QualType EltTy = LV->getElementType();
Douglas Gregor6972a622010-06-16 00:35:25 +00005936 if (EltTy->isIntegralType(Context) && rhsType->isIntegralType(Context)) {
John McCall8cb679e2010-11-15 09:13:47 +00005937 int order = Context.getIntegerTypeOrder(EltTy, rhsType);
5938 if (order > 0)
5939 ImpCastExprToType(rex, EltTy, CK_IntegralCast);
5940 if (order >= 0) {
5941 ImpCastExprToType(rex, lhsType, CK_VectorSplat);
Nate Begemanbd956c42009-06-28 02:36:38 +00005942 if (swapped) std::swap(rex, lex);
5943 return lhsType;
5944 }
5945 }
5946 if (EltTy->isRealFloatingType() && rhsType->isScalarType() &&
5947 rhsType->isRealFloatingType()) {
John McCall8cb679e2010-11-15 09:13:47 +00005948 int order = Context.getFloatingTypeOrder(EltTy, rhsType);
5949 if (order > 0)
5950 ImpCastExprToType(rex, EltTy, CK_FloatingCast);
5951 if (order >= 0) {
5952 ImpCastExprToType(rex, lhsType, CK_VectorSplat);
Nate Begemanbd956c42009-06-28 02:36:38 +00005953 if (swapped) std::swap(rex, lex);
5954 return lhsType;
5955 }
Nate Begeman330aaa72007-12-30 02:59:45 +00005956 }
5957 }
Mike Stump11289f42009-09-09 15:08:12 +00005958
Nate Begeman886448d2009-06-28 19:12:57 +00005959 // Vectors of different size or scalar and non-ext-vector are errors.
Chris Lattner377d1f82008-11-18 22:52:51 +00005960 Diag(Loc, diag::err_typecheck_vector_not_convertable)
Chris Lattner1e5665e2008-11-24 06:25:27 +00005961 << lex->getType() << rex->getType()
Chris Lattner377d1f82008-11-18 22:52:51 +00005962 << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff84ff4b42007-07-09 21:31:10 +00005963 return QualType();
Sebastian Redl112a97662009-02-07 00:15:38 +00005964}
5965
Chris Lattnerfaa54172010-01-12 21:23:57 +00005966QualType Sema::CheckMultiplyDivideOperands(
5967 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign, bool isDiv) {
Daniel Dunbar060d5e22009-01-05 22:42:10 +00005968 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
Chris Lattner326f7572008-11-18 01:30:42 +00005969 return CheckVectorOperands(Loc, lex, rex);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005970
Steve Naroffbe4c4d12007-08-24 19:07:16 +00005971 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005972
Chris Lattnerfaa54172010-01-12 21:23:57 +00005973 if (!lex->getType()->isArithmeticType() ||
5974 !rex->getType()->isArithmeticType())
5975 return InvalidOperands(Loc, lex, rex);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005976
Chris Lattnerfaa54172010-01-12 21:23:57 +00005977 // Check for division by zero.
5978 if (isDiv &&
5979 rex->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005980 DiagRuntimeBehavior(Loc, PDiag(diag::warn_division_by_zero)
Chris Lattner70117952010-01-12 21:30:55 +00005981 << rex->getSourceRange());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005982
Chris Lattnerfaa54172010-01-12 21:23:57 +00005983 return compType;
Steve Naroff26c8ea52007-03-21 21:08:52 +00005984}
5985
Chris Lattnerfaa54172010-01-12 21:23:57 +00005986QualType Sema::CheckRemainderOperands(
Mike Stump11289f42009-09-09 15:08:12 +00005987 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) {
Daniel Dunbar0d2bfec2009-01-05 22:55:36 +00005988 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00005989 if (lex->getType()->hasIntegerRepresentation() &&
5990 rex->getType()->hasIntegerRepresentation())
Daniel Dunbar0d2bfec2009-01-05 22:55:36 +00005991 return CheckVectorOperands(Loc, lex, rex);
5992 return InvalidOperands(Loc, lex, rex);
5993 }
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00005994
Steve Naroffbe4c4d12007-08-24 19:07:16 +00005995 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stump4e1f26a2009-02-19 03:04:26 +00005996
Chris Lattnerfaa54172010-01-12 21:23:57 +00005997 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
5998 return InvalidOperands(Loc, lex, rex);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005999
Chris Lattnerfaa54172010-01-12 21:23:57 +00006000 // Check for remainder by zero.
6001 if (rex->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
Chris Lattner70117952010-01-12 21:30:55 +00006002 DiagRuntimeBehavior(Loc, PDiag(diag::warn_remainder_by_zero)
6003 << rex->getSourceRange());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006004
Chris Lattnerfaa54172010-01-12 21:23:57 +00006005 return compType;
Steve Naroff218bc2b2007-05-04 21:54:46 +00006006}
6007
Chris Lattnerfaa54172010-01-12 21:23:57 +00006008QualType Sema::CheckAdditionOperands( // C99 6.5.6
Mike Stump11289f42009-09-09 15:08:12 +00006009 Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006010 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
6011 QualType compType = CheckVectorOperands(Loc, lex, rex);
6012 if (CompLHSTy) *CompLHSTy = compType;
6013 return compType;
6014 }
Steve Naroff7a5af782007-07-13 16:58:59 +00006015
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006016 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
Eli Friedman8e122982008-05-18 18:08:51 +00006017
Steve Naroffe4718892007-04-27 18:30:00 +00006018 // handle the common case first (both operands are arithmetic).
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006019 if (lex->getType()->isArithmeticType() &&
6020 rex->getType()->isArithmeticType()) {
6021 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroffbe4c4d12007-08-24 19:07:16 +00006022 return compType;
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006023 }
Steve Naroff218bc2b2007-05-04 21:54:46 +00006024
Eli Friedman8e122982008-05-18 18:08:51 +00006025 // Put any potential pointer into PExp
6026 Expr* PExp = lex, *IExp = rex;
Steve Naroff6b712a72009-07-14 18:25:06 +00006027 if (IExp->getType()->isAnyPointerType())
Eli Friedman8e122982008-05-18 18:08:51 +00006028 std::swap(PExp, IExp);
6029
Steve Naroff6b712a72009-07-14 18:25:06 +00006030 if (PExp->getType()->isAnyPointerType()) {
Mike Stump11289f42009-09-09 15:08:12 +00006031
Eli Friedman8e122982008-05-18 18:08:51 +00006032 if (IExp->getType()->isIntegerType()) {
Steve Naroffaacd4cc2009-07-13 21:20:41 +00006033 QualType PointeeTy = PExp->getType()->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00006034
Chris Lattner12bdebb2009-04-24 23:50:08 +00006035 // Check for arithmetic on pointers to incomplete types.
6036 if (PointeeTy->isVoidType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +00006037 if (getLangOptions().CPlusPlus) {
6038 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
Chris Lattner3b054132008-11-19 05:08:23 +00006039 << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregordd430f72009-01-19 19:26:10 +00006040 return QualType();
Eli Friedman8e122982008-05-18 18:08:51 +00006041 }
Douglas Gregorac1fb652009-03-24 19:52:54 +00006042
6043 // GNU extension: arithmetic on pointer to void
6044 Diag(Loc, diag::ext_gnu_void_ptr)
6045 << lex->getSourceRange() << rex->getSourceRange();
Chris Lattner12bdebb2009-04-24 23:50:08 +00006046 } else if (PointeeTy->isFunctionType()) {
Douglas Gregorac1fb652009-03-24 19:52:54 +00006047 if (getLangOptions().CPlusPlus) {
6048 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
6049 << lex->getType() << lex->getSourceRange();
6050 return QualType();
6051 }
6052
6053 // GNU extension: arithmetic on pointer to function
6054 Diag(Loc, diag::ext_gnu_ptr_func_arith)
6055 << lex->getType() << lex->getSourceRange();
Steve Naroffa63372d2009-07-13 21:32:29 +00006056 } else {
Steve Naroffaacd4cc2009-07-13 21:20:41 +00006057 // Check if we require a complete type.
Mike Stump11289f42009-09-09 15:08:12 +00006058 if (((PExp->getType()->isPointerType() &&
Steve Naroffa63372d2009-07-13 21:32:29 +00006059 !PExp->getType()->isDependentType()) ||
Steve Naroffaacd4cc2009-07-13 21:20:41 +00006060 PExp->getType()->isObjCObjectPointerType()) &&
6061 RequireCompleteType(Loc, PointeeTy,
Mike Stump11289f42009-09-09 15:08:12 +00006062 PDiag(diag::err_typecheck_arithmetic_incomplete_type)
6063 << PExp->getSourceRange()
Anders Carlsson029fc692009-08-26 22:59:12 +00006064 << PExp->getType()))
Steve Naroffaacd4cc2009-07-13 21:20:41 +00006065 return QualType();
6066 }
Chris Lattner12bdebb2009-04-24 23:50:08 +00006067 // Diagnose bad cases where we step over interface counts.
John McCall8b07ec22010-05-15 11:32:37 +00006068 if (PointeeTy->isObjCObjectType() && LangOpts.ObjCNonFragileABI) {
Chris Lattner12bdebb2009-04-24 23:50:08 +00006069 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
6070 << PointeeTy << PExp->getSourceRange();
6071 return QualType();
6072 }
Mike Stump11289f42009-09-09 15:08:12 +00006073
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006074 if (CompLHSTy) {
Eli Friedman629ffb92009-08-20 04:21:42 +00006075 QualType LHSTy = Context.isPromotableBitField(lex);
6076 if (LHSTy.isNull()) {
6077 LHSTy = lex->getType();
6078 if (LHSTy->isPromotableIntegerType())
6079 LHSTy = Context.getPromotedIntegerType(LHSTy);
Douglas Gregord2c2d172009-05-02 00:36:19 +00006080 }
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006081 *CompLHSTy = LHSTy;
6082 }
Eli Friedman8e122982008-05-18 18:08:51 +00006083 return PExp->getType();
6084 }
6085 }
6086
Chris Lattner326f7572008-11-18 01:30:42 +00006087 return InvalidOperands(Loc, lex, rex);
Steve Naroff26c8ea52007-03-21 21:08:52 +00006088}
6089
Chris Lattner2a3569b2008-04-07 05:30:13 +00006090// C99 6.5.6
6091QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006092 SourceLocation Loc, QualType* CompLHSTy) {
6093 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
6094 QualType compType = CheckVectorOperands(Loc, lex, rex);
6095 if (CompLHSTy) *CompLHSTy = compType;
6096 return compType;
6097 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006098
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006099 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006100
Chris Lattner4d62f422007-12-09 21:53:25 +00006101 // Enforce type constraints: C99 6.5.6p3.
Mike Stump4e1f26a2009-02-19 03:04:26 +00006102
Chris Lattner4d62f422007-12-09 21:53:25 +00006103 // Handle the common case first (both operands are arithmetic).
Mike Stumpf70bcf72009-05-07 18:43:07 +00006104 if (lex->getType()->isArithmeticType()
6105 && rex->getType()->isArithmeticType()) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006106 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroffbe4c4d12007-08-24 19:07:16 +00006107 return compType;
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006108 }
Mike Stump11289f42009-09-09 15:08:12 +00006109
Chris Lattner4d62f422007-12-09 21:53:25 +00006110 // Either ptr - int or ptr - ptr.
Steve Naroff6b712a72009-07-14 18:25:06 +00006111 if (lex->getType()->isAnyPointerType()) {
Steve Naroff4eed7a12009-07-13 17:19:15 +00006112 QualType lpointee = lex->getType()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006113
Douglas Gregorac1fb652009-03-24 19:52:54 +00006114 // The LHS must be an completely-defined object type.
Douglas Gregorf6cd9282009-01-23 00:36:41 +00006115
Douglas Gregorac1fb652009-03-24 19:52:54 +00006116 bool ComplainAboutVoid = false;
6117 Expr *ComplainAboutFunc = 0;
6118 if (lpointee->isVoidType()) {
6119 if (getLangOptions().CPlusPlus) {
6120 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
6121 << lex->getSourceRange() << rex->getSourceRange();
6122 return QualType();
6123 }
6124
6125 // GNU C extension: arithmetic on pointer to void
6126 ComplainAboutVoid = true;
6127 } else if (lpointee->isFunctionType()) {
6128 if (getLangOptions().CPlusPlus) {
6129 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006130 << lex->getType() << lex->getSourceRange();
Chris Lattner4d62f422007-12-09 21:53:25 +00006131 return QualType();
6132 }
Douglas Gregorac1fb652009-03-24 19:52:54 +00006133
6134 // GNU C extension: arithmetic on pointer to function
6135 ComplainAboutFunc = lex;
6136 } else if (!lpointee->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +00006137 RequireCompleteType(Loc, lpointee,
Anders Carlsson029fc692009-08-26 22:59:12 +00006138 PDiag(diag::err_typecheck_sub_ptr_object)
Mike Stump11289f42009-09-09 15:08:12 +00006139 << lex->getSourceRange()
Anders Carlsson029fc692009-08-26 22:59:12 +00006140 << lex->getType()))
Douglas Gregorac1fb652009-03-24 19:52:54 +00006141 return QualType();
Chris Lattner4d62f422007-12-09 21:53:25 +00006142
Chris Lattner12bdebb2009-04-24 23:50:08 +00006143 // Diagnose bad cases where we step over interface counts.
John McCall8b07ec22010-05-15 11:32:37 +00006144 if (lpointee->isObjCObjectType() && LangOpts.ObjCNonFragileABI) {
Chris Lattner12bdebb2009-04-24 23:50:08 +00006145 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
6146 << lpointee << lex->getSourceRange();
6147 return QualType();
6148 }
Mike Stump11289f42009-09-09 15:08:12 +00006149
Chris Lattner4d62f422007-12-09 21:53:25 +00006150 // The result type of a pointer-int computation is the pointer type.
Douglas Gregorac1fb652009-03-24 19:52:54 +00006151 if (rex->getType()->isIntegerType()) {
6152 if (ComplainAboutVoid)
6153 Diag(Loc, diag::ext_gnu_void_ptr)
6154 << lex->getSourceRange() << rex->getSourceRange();
6155 if (ComplainAboutFunc)
6156 Diag(Loc, diag::ext_gnu_ptr_func_arith)
Mike Stump11289f42009-09-09 15:08:12 +00006157 << ComplainAboutFunc->getType()
Douglas Gregorac1fb652009-03-24 19:52:54 +00006158 << ComplainAboutFunc->getSourceRange();
6159
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006160 if (CompLHSTy) *CompLHSTy = lex->getType();
Chris Lattner4d62f422007-12-09 21:53:25 +00006161 return lex->getType();
Douglas Gregorac1fb652009-03-24 19:52:54 +00006162 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006163
Chris Lattner4d62f422007-12-09 21:53:25 +00006164 // Handle pointer-pointer subtractions.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006165 if (const PointerType *RHSPTy = rex->getType()->getAs<PointerType>()) {
Eli Friedman1974e532008-02-08 01:19:44 +00006166 QualType rpointee = RHSPTy->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006167
Douglas Gregorac1fb652009-03-24 19:52:54 +00006168 // RHS must be a completely-type object type.
6169 // Handle the GNU void* extension.
6170 if (rpointee->isVoidType()) {
6171 if (getLangOptions().CPlusPlus) {
6172 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
6173 << lex->getSourceRange() << rex->getSourceRange();
6174 return QualType();
6175 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006176
Douglas Gregorac1fb652009-03-24 19:52:54 +00006177 ComplainAboutVoid = true;
6178 } else if (rpointee->isFunctionType()) {
6179 if (getLangOptions().CPlusPlus) {
6180 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006181 << rex->getType() << rex->getSourceRange();
Chris Lattner4d62f422007-12-09 21:53:25 +00006182 return QualType();
6183 }
Douglas Gregorac1fb652009-03-24 19:52:54 +00006184
6185 // GNU extension: arithmetic on pointer to function
6186 if (!ComplainAboutFunc)
6187 ComplainAboutFunc = rex;
6188 } else if (!rpointee->isDependentType() &&
6189 RequireCompleteType(Loc, rpointee,
Anders Carlsson029fc692009-08-26 22:59:12 +00006190 PDiag(diag::err_typecheck_sub_ptr_object)
6191 << rex->getSourceRange()
6192 << rex->getType()))
Douglas Gregorac1fb652009-03-24 19:52:54 +00006193 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006194
Eli Friedman168fe152009-05-16 13:54:38 +00006195 if (getLangOptions().CPlusPlus) {
6196 // Pointee types must be the same: C++ [expr.add]
6197 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
6198 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
6199 << lex->getType() << rex->getType()
6200 << lex->getSourceRange() << rex->getSourceRange();
6201 return QualType();
6202 }
6203 } else {
6204 // Pointee types must be compatible C99 6.5.6p3
6205 if (!Context.typesAreCompatible(
6206 Context.getCanonicalType(lpointee).getUnqualifiedType(),
6207 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
6208 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
6209 << lex->getType() << rex->getType()
6210 << lex->getSourceRange() << rex->getSourceRange();
6211 return QualType();
6212 }
Chris Lattner4d62f422007-12-09 21:53:25 +00006213 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006214
Douglas Gregorac1fb652009-03-24 19:52:54 +00006215 if (ComplainAboutVoid)
6216 Diag(Loc, diag::ext_gnu_void_ptr)
6217 << lex->getSourceRange() << rex->getSourceRange();
6218 if (ComplainAboutFunc)
6219 Diag(Loc, diag::ext_gnu_ptr_func_arith)
Mike Stump11289f42009-09-09 15:08:12 +00006220 << ComplainAboutFunc->getType()
Douglas Gregorac1fb652009-03-24 19:52:54 +00006221 << ComplainAboutFunc->getSourceRange();
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006222
6223 if (CompLHSTy) *CompLHSTy = lex->getType();
Chris Lattner4d62f422007-12-09 21:53:25 +00006224 return Context.getPointerDiffType();
6225 }
6226 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006227
Chris Lattner326f7572008-11-18 01:30:42 +00006228 return InvalidOperands(Loc, lex, rex);
Steve Naroff218bc2b2007-05-04 21:54:46 +00006229}
6230
Douglas Gregor0bf31402010-10-08 23:50:27 +00006231static bool isScopedEnumerationType(QualType T) {
6232 if (const EnumType *ET = dyn_cast<EnumType>(T))
6233 return ET->getDecl()->isScoped();
6234 return false;
6235}
6236
Chris Lattner2a3569b2008-04-07 05:30:13 +00006237// C99 6.5.7
Chris Lattner326f7572008-11-18 01:30:42 +00006238QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
Chris Lattner2a3569b2008-04-07 05:30:13 +00006239 bool isCompAssign) {
Chris Lattner5c11c412007-12-12 05:47:28 +00006240 // C99 6.5.7p2: Each of the operands shall have integer type.
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00006241 if (!lex->getType()->hasIntegerRepresentation() ||
6242 !rex->getType()->hasIntegerRepresentation())
Chris Lattner326f7572008-11-18 01:30:42 +00006243 return InvalidOperands(Loc, lex, rex);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006244
Douglas Gregor0bf31402010-10-08 23:50:27 +00006245 // C++0x: Don't allow scoped enums. FIXME: Use something better than
6246 // hasIntegerRepresentation() above instead of this.
6247 if (isScopedEnumerationType(lex->getType()) ||
6248 isScopedEnumerationType(rex->getType())) {
6249 return InvalidOperands(Loc, lex, rex);
6250 }
6251
Nate Begemane46ee9a2009-10-25 02:26:48 +00006252 // Vector shifts promote their scalar inputs to vector type.
6253 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
6254 return CheckVectorOperands(Loc, lex, rex);
6255
Chris Lattner5c11c412007-12-12 05:47:28 +00006256 // Shifts don't perform usual arithmetic conversions, they just do integer
6257 // promotions on each operand. C99 6.5.7p3
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006258
John McCall57cdd882010-12-16 19:28:59 +00006259 // For the LHS, do usual unary conversions, but then reset them away
6260 // if this is a compound assignment.
6261 Expr *old_lex = lex;
6262 UsualUnaryConversions(lex);
6263 QualType LHSTy = lex->getType();
6264 if (isCompAssign) lex = old_lex;
6265
6266 // The RHS is simpler.
Chris Lattner5c11c412007-12-12 05:47:28 +00006267 UsualUnaryConversions(rex);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006268
Ryan Flynnf53fab82009-08-07 16:20:20 +00006269 // Sanity-check shift operands
6270 llvm::APSInt Right;
6271 // Check right/shifter operand
Daniel Dunbar687fa862009-09-17 06:31:27 +00006272 if (!rex->isValueDependent() &&
6273 rex->isIntegerConstantExpr(Right, Context)) {
Ryan Flynn2f085712009-08-08 19:18:23 +00006274 if (Right.isNegative())
Ryan Flynnf53fab82009-08-07 16:20:20 +00006275 Diag(Loc, diag::warn_shift_negative) << rex->getSourceRange();
6276 else {
6277 llvm::APInt LeftBits(Right.getBitWidth(),
6278 Context.getTypeSize(lex->getType()));
6279 if (Right.uge(LeftBits))
6280 Diag(Loc, diag::warn_shift_gt_typewidth) << rex->getSourceRange();
6281 }
6282 }
6283
Chris Lattner5c11c412007-12-12 05:47:28 +00006284 // "The type of the result is that of the promoted left operand."
Eli Friedman8b7b1b12009-03-28 01:22:36 +00006285 return LHSTy;
Steve Naroff26c8ea52007-03-21 21:08:52 +00006286}
6287
Chandler Carruth17773fc2010-07-10 12:30:03 +00006288static bool IsWithinTemplateSpecialization(Decl *D) {
6289 if (DeclContext *DC = D->getDeclContext()) {
6290 if (isa<ClassTemplateSpecializationDecl>(DC))
6291 return true;
6292 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
6293 return FD->isFunctionTemplateSpecialization();
6294 }
6295 return false;
6296}
6297
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006298// C99 6.5.8, C++ [expr.rel]
Chris Lattner326f7572008-11-18 01:30:42 +00006299QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006300 unsigned OpaqueOpc, bool isRelational) {
John McCalle3027922010-08-25 11:45:40 +00006301 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc;
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006302
Chris Lattner9a152e22009-12-05 05:40:13 +00006303 // Handle vector comparisons separately.
Nate Begeman191a6b12008-07-14 18:02:46 +00006304 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
Chris Lattner326f7572008-11-18 01:30:42 +00006305 return CheckVectorCompareOperands(lex, rex, Loc, isRelational);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006306
Steve Naroff31090012007-07-16 21:54:35 +00006307 QualType lType = lex->getType();
6308 QualType rType = rex->getType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006309
Douglas Gregor4ffbad12010-06-22 22:12:46 +00006310 if (!lType->hasFloatingRepresentation() &&
Ted Kremenek853734e2010-09-16 00:03:01 +00006311 !(lType->isBlockPointerType() && isRelational) &&
6312 !lex->getLocStart().isMacroID() &&
6313 !rex->getLocStart().isMacroID()) {
Chris Lattner222b8bd2009-03-08 19:39:53 +00006314 // For non-floating point types, check for self-comparisons of the form
6315 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
6316 // often indicate logic errors in the program.
Chandler Carruth65a38182010-07-12 06:23:38 +00006317 //
6318 // NOTE: Don't warn about comparison expressions resulting from macro
6319 // expansion. Also don't warn about comparisons which are only self
6320 // comparisons within a template specialization. The warnings should catch
6321 // obvious cases in the definition of the template anyways. The idea is to
6322 // warn when the typed comparison operator will always evaluate to the same
6323 // result.
John McCall34376a62010-12-04 03:47:34 +00006324 Expr *LHSStripped = lex->IgnoreParenImpCasts();
6325 Expr *RHSStripped = rex->IgnoreParenImpCasts();
Chandler Carruth17773fc2010-07-10 12:30:03 +00006326 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) {
Douglas Gregorec170db2010-06-08 19:50:34 +00006327 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) {
Ted Kremenek853734e2010-09-16 00:03:01 +00006328 if (DRL->getDecl() == DRR->getDecl() &&
Chandler Carruth17773fc2010-07-10 12:30:03 +00006329 !IsWithinTemplateSpecialization(DRL->getDecl())) {
Douglas Gregorec170db2010-06-08 19:50:34 +00006330 DiagRuntimeBehavior(Loc, PDiag(diag::warn_comparison_always)
6331 << 0 // self-
John McCalle3027922010-08-25 11:45:40 +00006332 << (Opc == BO_EQ
6333 || Opc == BO_LE
6334 || Opc == BO_GE));
Douglas Gregorec170db2010-06-08 19:50:34 +00006335 } else if (lType->isArrayType() && rType->isArrayType() &&
6336 !DRL->getDecl()->getType()->isReferenceType() &&
6337 !DRR->getDecl()->getType()->isReferenceType()) {
6338 // what is it always going to eval to?
6339 char always_evals_to;
6340 switch(Opc) {
John McCalle3027922010-08-25 11:45:40 +00006341 case BO_EQ: // e.g. array1 == array2
Douglas Gregorec170db2010-06-08 19:50:34 +00006342 always_evals_to = 0; // false
6343 break;
John McCalle3027922010-08-25 11:45:40 +00006344 case BO_NE: // e.g. array1 != array2
Douglas Gregorec170db2010-06-08 19:50:34 +00006345 always_evals_to = 1; // true
6346 break;
6347 default:
6348 // best we can say is 'a constant'
6349 always_evals_to = 2; // e.g. array1 <= array2
6350 break;
6351 }
6352 DiagRuntimeBehavior(Loc, PDiag(diag::warn_comparison_always)
6353 << 1 // array
6354 << always_evals_to);
6355 }
6356 }
Chandler Carruth17773fc2010-07-10 12:30:03 +00006357 }
Mike Stump11289f42009-09-09 15:08:12 +00006358
Chris Lattner222b8bd2009-03-08 19:39:53 +00006359 if (isa<CastExpr>(LHSStripped))
6360 LHSStripped = LHSStripped->IgnoreParenCasts();
6361 if (isa<CastExpr>(RHSStripped))
6362 RHSStripped = RHSStripped->IgnoreParenCasts();
Mike Stump11289f42009-09-09 15:08:12 +00006363
Chris Lattner222b8bd2009-03-08 19:39:53 +00006364 // Warn about comparisons against a string constant (unless the other
6365 // operand is null), the user probably wants strcmp.
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006366 Expr *literalString = 0;
6367 Expr *literalStringStripped = 0;
Chris Lattner222b8bd2009-03-08 19:39:53 +00006368 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006369 !RHSStripped->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00006370 Expr::NPC_ValueDependentIsNull)) {
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006371 literalString = lex;
6372 literalStringStripped = LHSStripped;
Mike Stump12b8ce12009-08-04 21:02:39 +00006373 } else if ((isa<StringLiteral>(RHSStripped) ||
6374 isa<ObjCEncodeExpr>(RHSStripped)) &&
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006375 !LHSStripped->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00006376 Expr::NPC_ValueDependentIsNull)) {
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006377 literalString = rex;
6378 literalStringStripped = RHSStripped;
6379 }
6380
6381 if (literalString) {
6382 std::string resultComparison;
6383 switch (Opc) {
John McCalle3027922010-08-25 11:45:40 +00006384 case BO_LT: resultComparison = ") < 0"; break;
6385 case BO_GT: resultComparison = ") > 0"; break;
6386 case BO_LE: resultComparison = ") <= 0"; break;
6387 case BO_GE: resultComparison = ") >= 0"; break;
6388 case BO_EQ: resultComparison = ") == 0"; break;
6389 case BO_NE: resultComparison = ") != 0"; break;
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006390 default: assert(false && "Invalid comparison operator");
6391 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006392
Douglas Gregor49862b82010-01-12 23:18:54 +00006393 DiagRuntimeBehavior(Loc,
6394 PDiag(diag::warn_stringcompare)
6395 << isa<ObjCEncodeExpr>(literalStringStripped)
Ted Kremenek800b66b2010-04-09 20:26:53 +00006396 << literalString->getSourceRange());
Douglas Gregor7a5bc762009-04-06 18:45:53 +00006397 }
Ted Kremeneke451eae2007-10-29 16:58:49 +00006398 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006399
Douglas Gregorec170db2010-06-08 19:50:34 +00006400 // C99 6.5.8p3 / C99 6.5.9p4
6401 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
6402 UsualArithmeticConversions(lex, rex);
6403 else {
6404 UsualUnaryConversions(lex);
6405 UsualUnaryConversions(rex);
6406 }
6407
6408 lType = lex->getType();
6409 rType = rex->getType();
6410
Douglas Gregorca63811b2008-11-19 03:25:36 +00006411 // The result of comparisons is 'bool' in C++, 'int' in C.
Chris Lattner9a152e22009-12-05 05:40:13 +00006412 QualType ResultTy = getLangOptions().CPlusPlus ? Context.BoolTy:Context.IntTy;
Douglas Gregorca63811b2008-11-19 03:25:36 +00006413
Chris Lattnerb620c342007-08-26 01:18:55 +00006414 if (isRelational) {
6415 if (lType->isRealType() && rType->isRealType())
Douglas Gregorca63811b2008-11-19 03:25:36 +00006416 return ResultTy;
Chris Lattnerb620c342007-08-26 01:18:55 +00006417 } else {
Ted Kremeneke2763b02007-10-29 17:13:39 +00006418 // Check for comparisons of floating point operands using != and ==.
Douglas Gregor4ffbad12010-06-22 22:12:46 +00006419 if (lType->hasFloatingRepresentation())
Chris Lattner326f7572008-11-18 01:30:42 +00006420 CheckFloatComparison(Loc,lex,rex);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006421
Chris Lattnerb620c342007-08-26 01:18:55 +00006422 if (lType->isArithmeticType() && rType->isArithmeticType())
Douglas Gregorca63811b2008-11-19 03:25:36 +00006423 return ResultTy;
Chris Lattnerb620c342007-08-26 01:18:55 +00006424 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006425
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006426 bool LHSIsNull = lex->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00006427 Expr::NPC_ValueDependentIsNull);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006428 bool RHSIsNull = rex->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00006429 Expr::NPC_ValueDependentIsNull);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006430
Douglas Gregorf267edd2010-06-15 21:38:40 +00006431 // All of the following pointer-related warnings are GCC extensions, except
6432 // when handling null pointer constants.
Steve Naroff808eb8f2007-08-27 04:08:11 +00006433 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
Chris Lattner3a0702e2008-04-03 05:07:25 +00006434 QualType LCanPointeeTy =
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006435 Context.getCanonicalType(lType->getAs<PointerType>()->getPointeeType());
Chris Lattner3a0702e2008-04-03 05:07:25 +00006436 QualType RCanPointeeTy =
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006437 Context.getCanonicalType(rType->getAs<PointerType>()->getPointeeType());
Mike Stump4e1f26a2009-02-19 03:04:26 +00006438
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006439 if (getLangOptions().CPlusPlus) {
Eli Friedman16c209612009-08-23 00:27:47 +00006440 if (LCanPointeeTy == RCanPointeeTy)
6441 return ResultTy;
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00006442 if (!isRelational &&
6443 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
6444 // Valid unless comparison between non-null pointer and function pointer
6445 // This is a gcc extension compatibility comparison.
Douglas Gregorf267edd2010-06-15 21:38:40 +00006446 // In a SFINAE context, we treat this as a hard error to maintain
6447 // conformance with the C++ standard.
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00006448 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
6449 && !LHSIsNull && !RHSIsNull) {
Douglas Gregorf267edd2010-06-15 21:38:40 +00006450 Diag(Loc,
6451 isSFINAEContext()?
6452 diag::err_typecheck_comparison_of_fptr_to_void
6453 : diag::ext_typecheck_comparison_of_fptr_to_void)
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00006454 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregorf267edd2010-06-15 21:38:40 +00006455
6456 if (isSFINAEContext())
6457 return QualType();
6458
John McCalle3027922010-08-25 11:45:40 +00006459 ImpCastExprToType(rex, lType, CK_BitCast);
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00006460 return ResultTy;
6461 }
6462 }
Anders Carlssona95069c2010-11-04 03:17:43 +00006463
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006464 // C++ [expr.rel]p2:
6465 // [...] Pointer conversions (4.10) and qualification
6466 // conversions (4.4) are performed on pointer operands (or on
6467 // a pointer operand and a null pointer constant) to bring
6468 // them to their composite pointer type. [...]
6469 //
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006470 // C++ [expr.eq]p1 uses the same notion for (in)equality
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006471 // comparisons of pointers.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006472 bool NonStandardCompositeType = false;
Douglas Gregor19175ff2010-04-16 23:20:25 +00006473 QualType T = FindCompositePointerType(Loc, lex, rex,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006474 isSFINAEContext()? 0 : &NonStandardCompositeType);
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006475 if (T.isNull()) {
6476 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
6477 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
6478 return QualType();
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006479 } else if (NonStandardCompositeType) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006480 Diag(Loc,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006481 diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard)
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006482 << lType << rType << T
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006483 << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006484 }
6485
John McCalle3027922010-08-25 11:45:40 +00006486 ImpCastExprToType(lex, T, CK_BitCast);
6487 ImpCastExprToType(rex, T, CK_BitCast);
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00006488 return ResultTy;
6489 }
Eli Friedman16c209612009-08-23 00:27:47 +00006490 // C99 6.5.9p2 and C99 6.5.8p2
6491 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
6492 RCanPointeeTy.getUnqualifiedType())) {
6493 // Valid unless a relational comparison of function pointers
6494 if (isRelational && LCanPointeeTy->isFunctionType()) {
6495 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
6496 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
6497 }
6498 } else if (!isRelational &&
6499 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
6500 // Valid unless comparison between non-null pointer and function pointer
6501 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
6502 && !LHSIsNull && !RHSIsNull) {
6503 Diag(Loc, diag::ext_typecheck_comparison_of_fptr_to_void)
6504 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
6505 }
6506 } else {
6507 // Invalid
Chris Lattner377d1f82008-11-18 22:52:51 +00006508 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006509 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff75c17232007-06-13 21:41:08 +00006510 }
Eli Friedman16c209612009-08-23 00:27:47 +00006511 if (LCanPointeeTy != RCanPointeeTy)
John McCalle3027922010-08-25 11:45:40 +00006512 ImpCastExprToType(rex, lType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006513 return ResultTy;
Steve Naroffcdee44c2007-08-16 21:48:38 +00006514 }
Mike Stump11289f42009-09-09 15:08:12 +00006515
Sebastian Redl576fd422009-05-10 18:38:11 +00006516 if (getLangOptions().CPlusPlus) {
Anders Carlssona95069c2010-11-04 03:17:43 +00006517 // Comparison of nullptr_t with itself.
6518 if (lType->isNullPtrType() && rType->isNullPtrType())
6519 return ResultTy;
6520
Mike Stump11289f42009-09-09 15:08:12 +00006521 // Comparison of pointers with null pointer constants and equality
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006522 // comparisons of member pointers to null pointer constants.
Mike Stump11289f42009-09-09 15:08:12 +00006523 if (RHSIsNull &&
Anders Carlssona95069c2010-11-04 03:17:43 +00006524 ((lType->isPointerType() || lType->isNullPtrType()) ||
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006525 (!isRelational && lType->isMemberPointerType()))) {
Douglas Gregorf58ff322010-08-07 13:36:37 +00006526 ImpCastExprToType(rex, lType,
6527 lType->isMemberPointerType()
John McCalle3027922010-08-25 11:45:40 +00006528 ? CK_NullToMemberPointer
John McCalle84af4e2010-11-13 01:35:44 +00006529 : CK_NullToPointer);
Sebastian Redl576fd422009-05-10 18:38:11 +00006530 return ResultTy;
6531 }
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006532 if (LHSIsNull &&
Anders Carlssona95069c2010-11-04 03:17:43 +00006533 ((rType->isPointerType() || rType->isNullPtrType()) ||
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006534 (!isRelational && rType->isMemberPointerType()))) {
Douglas Gregorf58ff322010-08-07 13:36:37 +00006535 ImpCastExprToType(lex, rType,
6536 rType->isMemberPointerType()
John McCalle3027922010-08-25 11:45:40 +00006537 ? CK_NullToMemberPointer
John McCalle84af4e2010-11-13 01:35:44 +00006538 : CK_NullToPointer);
Sebastian Redl576fd422009-05-10 18:38:11 +00006539 return ResultTy;
6540 }
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006541
6542 // Comparison of member pointers.
Mike Stump11289f42009-09-09 15:08:12 +00006543 if (!isRelational &&
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006544 lType->isMemberPointerType() && rType->isMemberPointerType()) {
6545 // C++ [expr.eq]p2:
Mike Stump11289f42009-09-09 15:08:12 +00006546 // In addition, pointers to members can be compared, or a pointer to
6547 // member and a null pointer constant. Pointer to member conversions
6548 // (4.11) and qualification conversions (4.4) are performed to bring
6549 // them to a common type. If one operand is a null pointer constant,
6550 // the common type is the type of the other operand. Otherwise, the
6551 // common type is a pointer to member type similar (4.4) to the type
6552 // of one of the operands, with a cv-qualification signature (4.4)
6553 // that is the union of the cv-qualification signatures of the operand
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006554 // types.
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006555 bool NonStandardCompositeType = false;
Douglas Gregor19175ff2010-04-16 23:20:25 +00006556 QualType T = FindCompositePointerType(Loc, lex, rex,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006557 isSFINAEContext()? 0 : &NonStandardCompositeType);
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006558 if (T.isNull()) {
6559 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006560 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006561 return QualType();
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006562 } else if (NonStandardCompositeType) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006563 Diag(Loc,
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006564 diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard)
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006565 << lType << rType << T
Douglas Gregor6f5f6422010-02-25 22:29:57 +00006566 << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006567 }
Mike Stump11289f42009-09-09 15:08:12 +00006568
John McCalle3027922010-08-25 11:45:40 +00006569 ImpCastExprToType(lex, T, CK_BitCast);
6570 ImpCastExprToType(rex, T, CK_BitCast);
Douglas Gregorb00b10e2009-08-24 17:42:35 +00006571 return ResultTy;
6572 }
Sebastian Redl576fd422009-05-10 18:38:11 +00006573 }
Mike Stump11289f42009-09-09 15:08:12 +00006574
Steve Naroff081c7422008-09-04 15:10:53 +00006575 // Handle block pointer types.
Mike Stump1b821b42009-05-07 03:14:14 +00006576 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006577 QualType lpointee = lType->getAs<BlockPointerType>()->getPointeeType();
6578 QualType rpointee = rType->getAs<BlockPointerType>()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006579
Steve Naroff081c7422008-09-04 15:10:53 +00006580 if (!LHSIsNull && !RHSIsNull &&
Eli Friedmana6638ca2009-06-08 05:08:54 +00006581 !Context.typesAreCompatible(lpointee, rpointee)) {
Chris Lattner377d1f82008-11-18 22:52:51 +00006582 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006583 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff081c7422008-09-04 15:10:53 +00006584 }
John McCalle3027922010-08-25 11:45:40 +00006585 ImpCastExprToType(rex, lType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006586 return ResultTy;
Steve Naroff081c7422008-09-04 15:10:53 +00006587 }
Steve Naroffe18f94c2008-09-28 01:11:11 +00006588 // Allow block pointers to be compared with null pointer constants.
Mike Stump1b821b42009-05-07 03:14:14 +00006589 if (!isRelational
6590 && ((lType->isBlockPointerType() && rType->isPointerType())
6591 || (lType->isPointerType() && rType->isBlockPointerType()))) {
Steve Naroffe18f94c2008-09-28 01:11:11 +00006592 if (!LHSIsNull && !RHSIsNull) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006593 if (!((rType->isPointerType() && rType->getAs<PointerType>()
Mike Stump1b821b42009-05-07 03:14:14 +00006594 ->getPointeeType()->isVoidType())
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006595 || (lType->isPointerType() && lType->getAs<PointerType>()
Mike Stump1b821b42009-05-07 03:14:14 +00006596 ->getPointeeType()->isVoidType())))
6597 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
6598 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroffe18f94c2008-09-28 01:11:11 +00006599 }
John McCalle3027922010-08-25 11:45:40 +00006600 ImpCastExprToType(rex, lType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006601 return ResultTy;
Steve Naroffe18f94c2008-09-28 01:11:11 +00006602 }
Steve Naroff081c7422008-09-04 15:10:53 +00006603
Steve Naroff7cae42b2009-07-10 23:34:53 +00006604 if ((lType->isObjCObjectPointerType() || rType->isObjCObjectPointerType())) {
Steve Naroff1d4a9a32008-10-27 10:33:19 +00006605 if (lType->isPointerType() || rType->isPointerType()) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006606 const PointerType *LPT = lType->getAs<PointerType>();
6607 const PointerType *RPT = rType->getAs<PointerType>();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006608 bool LPtrToVoid = LPT ?
Steve Naroff753567f2008-11-17 19:49:16 +00006609 Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006610 bool RPtrToVoid = RPT ?
Steve Naroff753567f2008-11-17 19:49:16 +00006611 Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006612
Steve Naroff753567f2008-11-17 19:49:16 +00006613 if (!LPtrToVoid && !RPtrToVoid &&
6614 !Context.typesAreCompatible(lType, rType)) {
Chris Lattner377d1f82008-11-18 22:52:51 +00006615 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
Chris Lattner1e5665e2008-11-24 06:25:27 +00006616 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff1d4a9a32008-10-27 10:33:19 +00006617 }
John McCalle3027922010-08-25 11:45:40 +00006618 ImpCastExprToType(rex, lType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006619 return ResultTy;
Steve Naroffea54d9e2008-10-20 18:19:10 +00006620 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00006621 if (lType->isObjCObjectPointerType() && rType->isObjCObjectPointerType()) {
Chris Lattnerf8344db2009-08-22 18:58:31 +00006622 if (!Context.areComparableObjCPointerTypes(lType, rType))
Steve Naroff7cae42b2009-07-10 23:34:53 +00006623 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
6624 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
John McCalle3027922010-08-25 11:45:40 +00006625 ImpCastExprToType(rex, lType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006626 return ResultTy;
Steve Naroffb788d9b2008-06-03 14:04:54 +00006627 }
Fariborz Jahanian134cbef2007-12-20 01:06:58 +00006628 }
Douglas Gregorf267edd2010-06-15 21:38:40 +00006629 if ((lType->isAnyPointerType() && rType->isIntegerType()) ||
6630 (lType->isIntegerType() && rType->isAnyPointerType())) {
Chris Lattnerd99bd522009-08-23 00:03:44 +00006631 unsigned DiagID = 0;
Douglas Gregorf267edd2010-06-15 21:38:40 +00006632 bool isError = false;
6633 if ((LHSIsNull && lType->isIntegerType()) ||
6634 (RHSIsNull && rType->isIntegerType())) {
6635 if (isRelational && !getLangOptions().CPlusPlus)
Chris Lattnerd99bd522009-08-23 00:03:44 +00006636 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
Douglas Gregorf267edd2010-06-15 21:38:40 +00006637 } else if (isRelational && !getLangOptions().CPlusPlus)
Chris Lattnerd99bd522009-08-23 00:03:44 +00006638 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
Douglas Gregorf267edd2010-06-15 21:38:40 +00006639 else if (getLangOptions().CPlusPlus) {
6640 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
6641 isError = true;
6642 } else
Chris Lattnerd99bd522009-08-23 00:03:44 +00006643 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
Mike Stump11289f42009-09-09 15:08:12 +00006644
Chris Lattnerd99bd522009-08-23 00:03:44 +00006645 if (DiagID) {
Chris Lattnerf8344db2009-08-22 18:58:31 +00006646 Diag(Loc, DiagID)
Chris Lattnerd466ea12009-06-30 06:24:05 +00006647 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregorf267edd2010-06-15 21:38:40 +00006648 if (isError)
6649 return QualType();
Chris Lattnerf8344db2009-08-22 18:58:31 +00006650 }
Douglas Gregorf267edd2010-06-15 21:38:40 +00006651
6652 if (lType->isIntegerType())
John McCalle84af4e2010-11-13 01:35:44 +00006653 ImpCastExprToType(lex, rType,
6654 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
Chris Lattnerd99bd522009-08-23 00:03:44 +00006655 else
John McCalle84af4e2010-11-13 01:35:44 +00006656 ImpCastExprToType(rex, lType,
6657 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006658 return ResultTy;
Steve Naroff043d45d2007-05-15 02:32:35 +00006659 }
Douglas Gregorf267edd2010-06-15 21:38:40 +00006660
Steve Naroff4b191572008-09-04 16:56:14 +00006661 // Handle block pointers.
Mike Stumpf70bcf72009-05-07 18:43:07 +00006662 if (!isRelational && RHSIsNull
6663 && lType->isBlockPointerType() && rType->isIntegerType()) {
John McCalle84af4e2010-11-13 01:35:44 +00006664 ImpCastExprToType(rex, lType, CK_NullToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006665 return ResultTy;
Steve Naroff4b191572008-09-04 16:56:14 +00006666 }
Mike Stumpf70bcf72009-05-07 18:43:07 +00006667 if (!isRelational && LHSIsNull
6668 && lType->isIntegerType() && rType->isBlockPointerType()) {
John McCalle84af4e2010-11-13 01:35:44 +00006669 ImpCastExprToType(lex, rType, CK_NullToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00006670 return ResultTy;
Steve Naroff4b191572008-09-04 16:56:14 +00006671 }
Chris Lattner326f7572008-11-18 01:30:42 +00006672 return InvalidOperands(Loc, lex, rex);
Steve Naroff26c8ea52007-03-21 21:08:52 +00006673}
6674
Nate Begeman191a6b12008-07-14 18:02:46 +00006675/// CheckVectorCompareOperands - vector comparisons are a clang extension that
Mike Stump4e1f26a2009-02-19 03:04:26 +00006676/// operates on extended vector types. Instead of producing an IntTy result,
Nate Begeman191a6b12008-07-14 18:02:46 +00006677/// like a scalar comparison, a vector comparison produces a vector of integer
6678/// types.
6679QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
Chris Lattner326f7572008-11-18 01:30:42 +00006680 SourceLocation Loc,
Nate Begeman191a6b12008-07-14 18:02:46 +00006681 bool isRelational) {
6682 // Check to make sure we're operating on vectors of the same type and width,
6683 // Allowing one side to be a scalar of element type.
Chris Lattner326f7572008-11-18 01:30:42 +00006684 QualType vType = CheckVectorOperands(Loc, lex, rex);
Nate Begeman191a6b12008-07-14 18:02:46 +00006685 if (vType.isNull())
6686 return vType;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006687
Anton Yartsev3f8f2882010-11-18 03:19:30 +00006688 // If AltiVec, the comparison results in a numeric type, i.e.
6689 // bool for C++, int for C
6690 if (getLangOptions().AltiVec)
6691 return (getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy);
6692
Nate Begeman191a6b12008-07-14 18:02:46 +00006693 QualType lType = lex->getType();
6694 QualType rType = rex->getType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006695
Nate Begeman191a6b12008-07-14 18:02:46 +00006696 // For non-floating point types, check for self-comparisons of the form
6697 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
6698 // often indicate logic errors in the program.
Douglas Gregor4ffbad12010-06-22 22:12:46 +00006699 if (!lType->hasFloatingRepresentation()) {
Nate Begeman191a6b12008-07-14 18:02:46 +00006700 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
6701 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
6702 if (DRL->getDecl() == DRR->getDecl())
Douglas Gregorec170db2010-06-08 19:50:34 +00006703 DiagRuntimeBehavior(Loc,
6704 PDiag(diag::warn_comparison_always)
6705 << 0 // self-
6706 << 2 // "a constant"
6707 );
Nate Begeman191a6b12008-07-14 18:02:46 +00006708 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006709
Nate Begeman191a6b12008-07-14 18:02:46 +00006710 // Check for comparisons of floating point operands using != and ==.
Douglas Gregor4ffbad12010-06-22 22:12:46 +00006711 if (!isRelational && lType->hasFloatingRepresentation()) {
6712 assert (rType->hasFloatingRepresentation());
Chris Lattner326f7572008-11-18 01:30:42 +00006713 CheckFloatComparison(Loc,lex,rex);
Nate Begeman191a6b12008-07-14 18:02:46 +00006714 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006715
Nate Begeman191a6b12008-07-14 18:02:46 +00006716 // Return the type for the comparison, which is the same as vector type for
6717 // integer vectors, or an integer type of identical size and number of
6718 // elements for floating point vectors.
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00006719 if (lType->hasIntegerRepresentation())
Nate Begeman191a6b12008-07-14 18:02:46 +00006720 return lType;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006721
John McCall9dd450b2009-09-21 23:43:11 +00006722 const VectorType *VTy = lType->getAs<VectorType>();
Nate Begeman191a6b12008-07-14 18:02:46 +00006723 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
Nate Begeman2f2bdeb2009-01-18 03:20:47 +00006724 if (TypeSize == Context.getTypeSize(Context.IntTy))
Nate Begeman191a6b12008-07-14 18:02:46 +00006725 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
Chris Lattner5d688962009-03-31 07:46:52 +00006726 if (TypeSize == Context.getTypeSize(Context.LongTy))
Nate Begeman2f2bdeb2009-01-18 03:20:47 +00006727 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
6728
Mike Stump4e1f26a2009-02-19 03:04:26 +00006729 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
Nate Begeman2f2bdeb2009-01-18 03:20:47 +00006730 "Unhandled vector element size in vector compare");
Nate Begeman191a6b12008-07-14 18:02:46 +00006731 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
6732}
6733
Steve Naroff218bc2b2007-05-04 21:54:46 +00006734inline QualType Sema::CheckBitwiseOperands(
Mike Stump11289f42009-09-09 15:08:12 +00006735 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) {
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00006736 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
6737 if (lex->getType()->hasIntegerRepresentation() &&
6738 rex->getType()->hasIntegerRepresentation())
6739 return CheckVectorOperands(Loc, lex, rex);
6740
6741 return InvalidOperands(Loc, lex, rex);
6742 }
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00006743
Steve Naroffbe4c4d12007-08-24 19:07:16 +00006744 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006745
Douglas Gregor0bf31402010-10-08 23:50:27 +00006746 if (lex->getType()->isIntegralOrUnscopedEnumerationType() &&
6747 rex->getType()->isIntegralOrUnscopedEnumerationType())
Steve Naroffbe4c4d12007-08-24 19:07:16 +00006748 return compType;
Chris Lattner326f7572008-11-18 01:30:42 +00006749 return InvalidOperands(Loc, lex, rex);
Steve Naroff26c8ea52007-03-21 21:08:52 +00006750}
6751
Steve Naroff218bc2b2007-05-04 21:54:46 +00006752inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
Chris Lattner8406c512010-07-13 19:41:32 +00006753 Expr *&lex, Expr *&rex, SourceLocation Loc, unsigned Opc) {
6754
6755 // Diagnose cases where the user write a logical and/or but probably meant a
6756 // bitwise one. We do this when the LHS is a non-bool integer and the RHS
6757 // is a constant.
6758 if (lex->getType()->isIntegerType() && !lex->getType()->isBooleanType() &&
Eli Friedman6b197e02010-07-27 19:14:53 +00006759 rex->getType()->isIntegerType() && !rex->isValueDependent() &&
Chris Lattnerdeee7a32010-07-15 00:26:43 +00006760 // Don't warn in macros.
Chris Lattner938533d2010-07-24 01:10:11 +00006761 !Loc.isMacroID()) {
6762 // If the RHS can be constant folded, and if it constant folds to something
6763 // that isn't 0 or 1 (which indicate a potential logical operation that
6764 // happened to fold to true/false) then warn.
6765 Expr::EvalResult Result;
6766 if (rex->Evaluate(Result, Context) && !Result.HasSideEffects &&
6767 Result.Val.getInt() != 0 && Result.Val.getInt() != 1) {
6768 Diag(Loc, diag::warn_logical_instead_of_bitwise)
6769 << rex->getSourceRange()
John McCalle3027922010-08-25 11:45:40 +00006770 << (Opc == BO_LAnd ? "&&" : "||")
6771 << (Opc == BO_LAnd ? "&" : "|");
Chris Lattner938533d2010-07-24 01:10:11 +00006772 }
6773 }
Chris Lattner8406c512010-07-13 19:41:32 +00006774
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006775 if (!Context.getLangOptions().CPlusPlus) {
6776 UsualUnaryConversions(lex);
6777 UsualUnaryConversions(rex);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006778
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006779 if (!lex->getType()->isScalarType() || !rex->getType()->isScalarType())
6780 return InvalidOperands(Loc, lex, rex);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006781
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006782 return Context.IntTy;
Anders Carlsson35a99d92009-10-16 01:44:21 +00006783 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006784
John McCall4a2429a2010-06-04 00:29:51 +00006785 // The following is safe because we only use this method for
6786 // non-overloadable operands.
6787
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006788 // C++ [expr.log.and]p1
6789 // C++ [expr.log.or]p1
John McCall4a2429a2010-06-04 00:29:51 +00006790 // The operands are both contextually converted to type bool.
6791 if (PerformContextuallyConvertToBool(lex) ||
6792 PerformContextuallyConvertToBool(rex))
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006793 return InvalidOperands(Loc, lex, rex);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006794
Anders Carlsson2e7bc112009-11-23 21:47:44 +00006795 // C++ [expr.log.and]p2
6796 // C++ [expr.log.or]p2
6797 // The result is a bool.
6798 return Context.BoolTy;
Steve Naroffae4143e2007-04-26 20:39:23 +00006799}
6800
Fariborz Jahanian8e1555c2009-01-12 19:55:42 +00006801/// IsReadonlyProperty - Verify that otherwise a valid l-value expression
6802/// is a read-only property; return true if so. A readonly property expression
6803/// depends on various declarations and thus must be treated specially.
6804///
Mike Stump11289f42009-09-09 15:08:12 +00006805static bool IsReadonlyProperty(Expr *E, Sema &S) {
Fariborz Jahanian8e1555c2009-01-12 19:55:42 +00006806 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) {
6807 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E);
John McCallb7bd14f2010-12-02 01:19:52 +00006808 if (PropExpr->isImplicitProperty()) return false;
6809
6810 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty();
6811 QualType BaseType = PropExpr->isSuperReceiver() ?
6812 PropExpr->getSuperReceiverType() :
Fariborz Jahanian681c0752010-10-14 16:04:05 +00006813 PropExpr->getBase()->getType();
6814
John McCallb7bd14f2010-12-02 01:19:52 +00006815 if (const ObjCObjectPointerType *OPT =
6816 BaseType->getAsObjCInterfacePointerType())
6817 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl())
6818 if (S.isPropertyReadonly(PDecl, IFace))
6819 return true;
Fariborz Jahanian8e1555c2009-01-12 19:55:42 +00006820 }
6821 return false;
6822}
6823
Chris Lattner30bd3272008-11-18 01:22:49 +00006824/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
6825/// emit an error and return true. If so, return false.
6826static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00006827 SourceLocation OrigLoc = Loc;
Mike Stump11289f42009-09-09 15:08:12 +00006828 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00006829 &Loc);
Fariborz Jahanian8e1555c2009-01-12 19:55:42 +00006830 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S))
6831 IsLV = Expr::MLV_ReadonlyProperty;
Chris Lattner30bd3272008-11-18 01:22:49 +00006832 if (IsLV == Expr::MLV_Valid)
6833 return false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006834
Chris Lattner30bd3272008-11-18 01:22:49 +00006835 unsigned Diag = 0;
6836 bool NeedType = false;
6837 switch (IsLV) { // C99 6.5.16p2
Chris Lattner30bd3272008-11-18 01:22:49 +00006838 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006839 case Expr::MLV_ArrayType:
Chris Lattner30bd3272008-11-18 01:22:49 +00006840 Diag = diag::err_typecheck_array_not_modifiable_lvalue;
6841 NeedType = true;
6842 break;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006843 case Expr::MLV_NotObjectType:
Chris Lattner30bd3272008-11-18 01:22:49 +00006844 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
6845 NeedType = true;
6846 break;
Chris Lattner9b3bbe92008-11-17 19:51:54 +00006847 case Expr::MLV_LValueCast:
Chris Lattner30bd3272008-11-18 01:22:49 +00006848 Diag = diag::err_typecheck_lvalue_casts_not_supported;
6849 break;
Douglas Gregorb154fdc2010-02-16 21:39:57 +00006850 case Expr::MLV_Valid:
6851 llvm_unreachable("did not take early return for MLV_Valid");
Chris Lattner9bad62c2008-01-04 18:04:52 +00006852 case Expr::MLV_InvalidExpression:
Douglas Gregorb154fdc2010-02-16 21:39:57 +00006853 case Expr::MLV_MemberFunction:
6854 case Expr::MLV_ClassTemporary:
Chris Lattner30bd3272008-11-18 01:22:49 +00006855 Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
6856 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +00006857 case Expr::MLV_IncompleteType:
6858 case Expr::MLV_IncompleteVoidType:
Douglas Gregored0cfbd2009-03-09 16:13:40 +00006859 return S.RequireCompleteType(Loc, E->getType(),
Douglas Gregor89336232010-03-29 23:34:08 +00006860 S.PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue)
Anders Carlssond624e162009-08-26 23:45:07 +00006861 << E->getSourceRange());
Chris Lattner9bad62c2008-01-04 18:04:52 +00006862 case Expr::MLV_DuplicateVectorComponents:
Chris Lattner30bd3272008-11-18 01:22:49 +00006863 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
6864 break;
Steve Naroffba756cb2008-09-26 14:41:28 +00006865 case Expr::MLV_NotBlockQualified:
Chris Lattner30bd3272008-11-18 01:22:49 +00006866 Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
6867 break;
Fariborz Jahanian8a1810f2008-11-22 18:39:36 +00006868 case Expr::MLV_ReadonlyProperty:
6869 Diag = diag::error_readonly_property_assignment;
6870 break;
Fariborz Jahanian5118c412008-11-22 20:25:50 +00006871 case Expr::MLV_NoSetterProperty:
6872 Diag = diag::error_nosetter_property_assignment;
6873 break;
Fariborz Jahaniane8d28902009-12-15 23:59:41 +00006874 case Expr::MLV_SubObjCPropertySetting:
6875 Diag = diag::error_no_subobject_property_setting;
6876 break;
Steve Naroff218bc2b2007-05-04 21:54:46 +00006877 }
Steve Naroffad373bd2007-07-31 12:34:36 +00006878
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00006879 SourceRange Assign;
6880 if (Loc != OrigLoc)
6881 Assign = SourceRange(OrigLoc, OrigLoc);
Chris Lattner30bd3272008-11-18 01:22:49 +00006882 if (NeedType)
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00006883 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
Chris Lattner30bd3272008-11-18 01:22:49 +00006884 else
Mike Stump11289f42009-09-09 15:08:12 +00006885 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
Chris Lattner30bd3272008-11-18 01:22:49 +00006886 return true;
6887}
6888
6889
6890
6891// C99 6.5.16.1
Chris Lattner326f7572008-11-18 01:30:42 +00006892QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS,
6893 SourceLocation Loc,
6894 QualType CompoundType) {
6895 // Verify that LHS is a modifiable lvalue, and emit error if not.
6896 if (CheckForModifiableLvalue(LHS, Loc, *this))
Chris Lattner30bd3272008-11-18 01:22:49 +00006897 return QualType();
Chris Lattner326f7572008-11-18 01:30:42 +00006898
6899 QualType LHSType = LHS->getType();
6900 QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType;
Chris Lattner9bad62c2008-01-04 18:04:52 +00006901 AssignConvertType ConvTy;
Chris Lattner326f7572008-11-18 01:30:42 +00006902 if (CompoundType.isNull()) {
Fariborz Jahanianbe21aa32010-06-07 22:02:01 +00006903 QualType LHSTy(LHSType);
Chris Lattnerea714382008-08-21 18:04:13 +00006904 // Simple assignment "x = y".
John McCall34376a62010-12-04 03:47:34 +00006905 if (LHS->getObjectKind() == OK_ObjCProperty)
6906 ConvertPropertyForLValue(LHS, RHS, LHSTy);
Fariborz Jahanianbe21aa32010-06-07 22:02:01 +00006907 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
Fariborz Jahanian255c0952009-01-13 23:34:40 +00006908 // Special case of NSObject attributes on c-style pointer types.
6909 if (ConvTy == IncompatiblePointer &&
6910 ((Context.isObjCNSObjectType(LHSType) &&
Steve Naroff79d12152009-07-16 15:41:00 +00006911 RHSType->isObjCObjectPointerType()) ||
Fariborz Jahanian255c0952009-01-13 23:34:40 +00006912 (Context.isObjCNSObjectType(RHSType) &&
Steve Naroff79d12152009-07-16 15:41:00 +00006913 LHSType->isObjCObjectPointerType())))
Fariborz Jahanian255c0952009-01-13 23:34:40 +00006914 ConvTy = Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006915
John McCall7decc9e2010-11-18 06:31:45 +00006916 if (ConvTy == Compatible &&
6917 getLangOptions().ObjCNonFragileABI &&
6918 LHSType->isObjCObjectType())
6919 Diag(Loc, diag::err_assignment_requires_nonfragile_object)
6920 << LHSType;
6921
Chris Lattnerea714382008-08-21 18:04:13 +00006922 // If the RHS is a unary plus or minus, check to see if they = and + are
6923 // right next to each other. If so, the user may have typo'd "x =+ 4"
6924 // instead of "x += 4".
Chris Lattner326f7572008-11-18 01:30:42 +00006925 Expr *RHSCheck = RHS;
Chris Lattnerea714382008-08-21 18:04:13 +00006926 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
6927 RHSCheck = ICE->getSubExpr();
6928 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
John McCalle3027922010-08-25 11:45:40 +00006929 if ((UO->getOpcode() == UO_Plus ||
6930 UO->getOpcode() == UO_Minus) &&
Chris Lattner326f7572008-11-18 01:30:42 +00006931 Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
Chris Lattnerea714382008-08-21 18:04:13 +00006932 // Only if the two operators are exactly adjacent.
Chris Lattner36c39c92009-03-08 06:51:10 +00006933 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() &&
6934 // And there is a space or other character before the subexpr of the
6935 // unary +/-. We don't want to warn on "x=-1".
Chris Lattnered9f14c2009-03-09 07:11:10 +00006936 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
6937 UO->getSubExpr()->getLocStart().isFileID()) {
Chris Lattner29e812b2008-11-20 06:06:08 +00006938 Diag(Loc, diag::warn_not_compound_assign)
John McCalle3027922010-08-25 11:45:40 +00006939 << (UO->getOpcode() == UO_Plus ? "+" : "-")
Chris Lattner29e812b2008-11-20 06:06:08 +00006940 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
Chris Lattner36c39c92009-03-08 06:51:10 +00006941 }
Chris Lattnerea714382008-08-21 18:04:13 +00006942 }
6943 } else {
6944 // Compound assignment "x += y"
John McCall29600e12010-11-16 02:32:08 +00006945 ConvTy = CheckAssignmentConstraints(LHSType, RHSType);
Chris Lattnerea714382008-08-21 18:04:13 +00006946 }
Chris Lattner9bad62c2008-01-04 18:04:52 +00006947
Chris Lattner326f7572008-11-18 01:30:42 +00006948 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
Douglas Gregor7c3bbdf2009-12-16 03:45:30 +00006949 RHS, AA_Assigning))
Chris Lattner9bad62c2008-01-04 18:04:52 +00006950 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006951
Chris Lattner39561062010-07-07 06:14:23 +00006952
6953 // Check to see if the destination operand is a dereferenced null pointer. If
6954 // so, and if not volatile-qualified, this is undefined behavior that the
6955 // optimizer will delete, so warn about it. People sometimes try to use this
6956 // to get a deterministic trap and are surprised by clang's behavior. This
6957 // only handles the pattern "*null = whatever", which is a very syntactic
6958 // check.
6959 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS->IgnoreParenCasts()))
John McCalle3027922010-08-25 11:45:40 +00006960 if (UO->getOpcode() == UO_Deref &&
Chris Lattner39561062010-07-07 06:14:23 +00006961 UO->getSubExpr()->IgnoreParenCasts()->
6962 isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) &&
6963 !UO->getType().isVolatileQualified()) {
6964 Diag(UO->getOperatorLoc(), diag::warn_indirection_through_null)
6965 << UO->getSubExpr()->getSourceRange();
6966 Diag(UO->getOperatorLoc(), diag::note_indirection_through_null);
6967 }
6968
Steve Naroff98cf3e92007-06-06 18:38:38 +00006969 // C99 6.5.16p3: The type of an assignment expression is the type of the
6970 // left operand unless the left operand has qualified type, in which case
Mike Stump4e1f26a2009-02-19 03:04:26 +00006971 // it is the unqualified version of the type of the left operand.
Steve Naroff98cf3e92007-06-06 18:38:38 +00006972 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
6973 // is converted to the type of the assignment expression (above).
Chris Lattnerf17bd422007-08-30 17:45:32 +00006974 // C++ 5.17p1: the type of the assignment expression is that of its left
Douglas Gregord2c2d172009-05-02 00:36:19 +00006975 // operand.
John McCall01cbf2d2010-10-12 02:19:57 +00006976 return (getLangOptions().CPlusPlus
6977 ? LHSType : LHSType.getUnqualifiedType());
Steve Naroffae4143e2007-04-26 20:39:23 +00006978}
6979
Chris Lattner326f7572008-11-18 01:30:42 +00006980// C99 6.5.17
John McCall34376a62010-12-04 03:47:34 +00006981static QualType CheckCommaOperands(Sema &S, Expr *&LHS, Expr *&RHS,
John McCall4bc41ae2010-11-18 19:01:18 +00006982 SourceLocation Loc) {
6983 S.DiagnoseUnusedExprResult(LHS);
Argyrios Kyrtzidis639ffb02010-06-30 10:53:14 +00006984
John McCall4bc41ae2010-11-18 19:01:18 +00006985 ExprResult LHSResult = S.CheckPlaceholderExpr(LHS, Loc);
Douglas Gregor0124e9b2010-11-09 21:07:58 +00006986 if (LHSResult.isInvalid())
6987 return QualType();
6988
John McCall4bc41ae2010-11-18 19:01:18 +00006989 ExprResult RHSResult = S.CheckPlaceholderExpr(RHS, Loc);
Douglas Gregor0124e9b2010-11-09 21:07:58 +00006990 if (RHSResult.isInvalid())
6991 return QualType();
6992 RHS = RHSResult.take();
6993
John McCall73d36182010-10-12 07:14:40 +00006994 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its
6995 // operands, but not unary promotions.
6996 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
Eli Friedmanba961a92009-03-23 00:24:07 +00006997
John McCall34376a62010-12-04 03:47:34 +00006998 // So we treat the LHS as a ignored value, and in C++ we allow the
6999 // containing site to determine what should be done with the RHS.
7000 S.IgnoredValueConversions(LHS);
7001
7002 if (!S.getLangOptions().CPlusPlus) {
John McCall4bc41ae2010-11-18 19:01:18 +00007003 S.DefaultFunctionArrayLvalueConversion(RHS);
John McCall73d36182010-10-12 07:14:40 +00007004 if (!RHS->getType()->isVoidType())
John McCall4bc41ae2010-11-18 19:01:18 +00007005 S.RequireCompleteType(Loc, RHS->getType(), diag::err_incomplete_type);
John McCall73d36182010-10-12 07:14:40 +00007006 }
Eli Friedmanba961a92009-03-23 00:24:07 +00007007
Chris Lattner326f7572008-11-18 01:30:42 +00007008 return RHS->getType();
Steve Naroff95af0132007-03-30 23:47:58 +00007009}
7010
Steve Naroff7a5af782007-07-13 16:58:59 +00007011/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
7012/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
John McCall4bc41ae2010-11-18 19:01:18 +00007013static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
7014 ExprValueKind &VK,
7015 SourceLocation OpLoc,
7016 bool isInc, bool isPrefix) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007017 if (Op->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00007018 return S.Context.DependentTy;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007019
Chris Lattner6b0cf142008-11-21 07:05:48 +00007020 QualType ResType = Op->getType();
7021 assert(!ResType.isNull() && "no type for increment/decrement expression");
Steve Naroffd50c88e2007-04-05 21:15:20 +00007022
John McCall4bc41ae2010-11-18 19:01:18 +00007023 if (S.getLangOptions().CPlusPlus && ResType->isBooleanType()) {
Sebastian Redle10c2c32008-12-20 09:35:34 +00007024 // Decrement of bool is not allowed.
7025 if (!isInc) {
John McCall4bc41ae2010-11-18 19:01:18 +00007026 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
Sebastian Redle10c2c32008-12-20 09:35:34 +00007027 return QualType();
7028 }
7029 // Increment of bool sets it to true, but is deprecated.
John McCall4bc41ae2010-11-18 19:01:18 +00007030 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
Sebastian Redle10c2c32008-12-20 09:35:34 +00007031 } else if (ResType->isRealType()) {
Chris Lattner6b0cf142008-11-21 07:05:48 +00007032 // OK!
Steve Naroff6b712a72009-07-14 18:25:06 +00007033 } else if (ResType->isAnyPointerType()) {
7034 QualType PointeeTy = ResType->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00007035
Chris Lattner6b0cf142008-11-21 07:05:48 +00007036 // C99 6.5.2.4p2, 6.5.6p2
Steve Naroff7cae42b2009-07-10 23:34:53 +00007037 if (PointeeTy->isVoidType()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007038 if (S.getLangOptions().CPlusPlus) {
7039 S.Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type)
Douglas Gregorf6cd9282009-01-23 00:36:41 +00007040 << Op->getSourceRange();
7041 return QualType();
7042 }
7043
7044 // Pointer to void is a GNU extension in C.
John McCall4bc41ae2010-11-18 19:01:18 +00007045 S.Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange();
Steve Naroff7cae42b2009-07-10 23:34:53 +00007046 } else if (PointeeTy->isFunctionType()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007047 if (S.getLangOptions().CPlusPlus) {
7048 S.Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type)
Douglas Gregorf6cd9282009-01-23 00:36:41 +00007049 << Op->getType() << Op->getSourceRange();
7050 return QualType();
7051 }
7052
John McCall4bc41ae2010-11-18 19:01:18 +00007053 S.Diag(OpLoc, diag::ext_gnu_ptr_func_arith)
Chris Lattner1e5665e2008-11-24 06:25:27 +00007054 << ResType << Op->getSourceRange();
John McCall4bc41ae2010-11-18 19:01:18 +00007055 } else if (S.RequireCompleteType(OpLoc, PointeeTy,
7056 S.PDiag(diag::err_typecheck_arithmetic_incomplete_type)
Mike Stump11289f42009-09-09 15:08:12 +00007057 << Op->getSourceRange()
Anders Carlsson029fc692009-08-26 22:59:12 +00007058 << ResType))
Douglas Gregordd430f72009-01-19 19:26:10 +00007059 return QualType();
Fariborz Jahanianca75db72009-07-16 17:59:14 +00007060 // Diagnose bad cases where we step over interface counts.
John McCall4bc41ae2010-11-18 19:01:18 +00007061 else if (PointeeTy->isObjCObjectType() && S.LangOpts.ObjCNonFragileABI) {
7062 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface)
Fariborz Jahanianca75db72009-07-16 17:59:14 +00007063 << PointeeTy << Op->getSourceRange();
7064 return QualType();
7065 }
Eli Friedman090addd2010-01-03 00:20:48 +00007066 } else if (ResType->isAnyComplexType()) {
Chris Lattner6b0cf142008-11-21 07:05:48 +00007067 // C99 does not support ++/-- on complex types, we allow as an extension.
John McCall4bc41ae2010-11-18 19:01:18 +00007068 S.Diag(OpLoc, diag::ext_integer_increment_complex)
Chris Lattner1e5665e2008-11-24 06:25:27 +00007069 << ResType << Op->getSourceRange();
John McCall36226622010-10-12 02:09:17 +00007070 } else if (ResType->isPlaceholderType()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007071 ExprResult PR = S.CheckPlaceholderExpr(Op, OpLoc);
John McCall36226622010-10-12 02:09:17 +00007072 if (PR.isInvalid()) return QualType();
John McCall4bc41ae2010-11-18 19:01:18 +00007073 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc,
7074 isInc, isPrefix);
Chris Lattner6b0cf142008-11-21 07:05:48 +00007075 } else {
John McCall4bc41ae2010-11-18 19:01:18 +00007076 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
Douglas Gregor906db8a2009-12-15 16:44:32 +00007077 << ResType << int(isInc) << Op->getSourceRange();
Chris Lattner6b0cf142008-11-21 07:05:48 +00007078 return QualType();
Steve Naroff46ba1eb2007-04-03 23:13:13 +00007079 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007080 // At this point, we know we have a real, complex or pointer type.
Steve Naroff9e1e5512007-08-23 21:37:33 +00007081 // Now make sure the operand is a modifiable lvalue.
John McCall4bc41ae2010-11-18 19:01:18 +00007082 if (CheckForModifiableLvalue(Op, OpLoc, S))
Steve Naroff35d85152007-05-07 00:24:15 +00007083 return QualType();
Alexis Huntc46382e2010-04-28 23:02:27 +00007084 // In C++, a prefix increment is the same type as the operand. Otherwise
7085 // (in C or with postfix), the increment is the unqualified type of the
7086 // operand.
John McCall4bc41ae2010-11-18 19:01:18 +00007087 if (isPrefix && S.getLangOptions().CPlusPlus) {
7088 VK = VK_LValue;
7089 return ResType;
7090 } else {
7091 VK = VK_RValue;
7092 return ResType.getUnqualifiedType();
7093 }
Steve Naroff26c8ea52007-03-21 21:08:52 +00007094}
7095
John McCall34376a62010-12-04 03:47:34 +00007096void Sema::ConvertPropertyForRValue(Expr *&E) {
7097 assert(E->getValueKind() == VK_LValue &&
7098 E->getObjectKind() == OK_ObjCProperty);
7099 const ObjCPropertyRefExpr *PRE = E->getObjCProperty();
7100
7101 ExprValueKind VK = VK_RValue;
7102 if (PRE->isImplicitProperty()) {
Fariborz Jahanian0f0b3022010-12-22 19:46:35 +00007103 if (const ObjCMethodDecl *GetterMethod =
7104 PRE->getImplicitPropertyGetter()) {
7105 QualType Result = GetterMethod->getResultType();
7106 VK = Expr::getValueKindForType(Result);
7107 }
7108 else {
7109 Diag(PRE->getLocation(), diag::err_getter_not_found)
7110 << PRE->getBase()->getType();
7111 }
John McCall34376a62010-12-04 03:47:34 +00007112 }
7113
7114 E = ImplicitCastExpr::Create(Context, E->getType(), CK_GetObjCProperty,
7115 E, 0, VK);
John McCall4f26cd82010-12-10 01:49:45 +00007116
7117 ExprResult Result = MaybeBindToTemporary(E);
7118 if (!Result.isInvalid())
7119 E = Result.take();
John McCall34376a62010-12-04 03:47:34 +00007120}
7121
7122void Sema::ConvertPropertyForLValue(Expr *&LHS, Expr *&RHS, QualType &LHSTy) {
7123 assert(LHS->getValueKind() == VK_LValue &&
7124 LHS->getObjectKind() == OK_ObjCProperty);
7125 const ObjCPropertyRefExpr *PRE = LHS->getObjCProperty();
7126
7127 if (PRE->isImplicitProperty()) {
7128 // If using property-dot syntax notation for assignment, and there is a
7129 // setter, RHS expression is being passed to the setter argument. So,
7130 // type conversion (and comparison) is RHS to setter's argument type.
7131 if (const ObjCMethodDecl *SetterMD = PRE->getImplicitPropertySetter()) {
7132 ObjCMethodDecl::param_iterator P = SetterMD->param_begin();
7133 LHSTy = (*P)->getType();
7134
7135 // Otherwise, if the getter returns an l-value, just call that.
7136 } else {
7137 QualType Result = PRE->getImplicitPropertyGetter()->getResultType();
7138 ExprValueKind VK = Expr::getValueKindForType(Result);
7139 if (VK == VK_LValue) {
7140 LHS = ImplicitCastExpr::Create(Context, LHS->getType(),
7141 CK_GetObjCProperty, LHS, 0, VK);
7142 return;
John McCallb7bd14f2010-12-02 01:19:52 +00007143 }
Fariborz Jahanian805b74e2010-09-14 23:02:38 +00007144 }
John McCall34376a62010-12-04 03:47:34 +00007145 }
7146
7147 if (getLangOptions().CPlusPlus && LHSTy->isRecordType()) {
Fariborz Jahanian805b74e2010-09-14 23:02:38 +00007148 InitializedEntity Entity =
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00007149 InitializedEntity::InitializeParameter(Context, LHSTy);
Fariborz Jahanian805b74e2010-09-14 23:02:38 +00007150 Expr *Arg = RHS;
7151 ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(),
7152 Owned(Arg));
7153 if (!ArgE.isInvalid())
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00007154 RHS = ArgE.takeAs<Expr>();
Fariborz Jahanian805b74e2010-09-14 23:02:38 +00007155 }
7156}
7157
7158
Anders Carlsson806700f2008-02-01 07:15:58 +00007159/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
Steve Naroff47500512007-04-19 23:00:49 +00007160/// This routine allows us to typecheck complex/recursive expressions
Daniel Dunbarb692ef42008-08-04 20:02:37 +00007161/// where the declaration is needed for type checking. We only need to
7162/// handle cases when the expression references a function designator
7163/// or is an lvalue. Here are some examples:
7164/// - &(x) => x
7165/// - &*****f => f for f a function designator.
7166/// - &s.xx => s
7167/// - &s.zz[1].yy -> s, if zz is an array
7168/// - *(x + 1) -> x, if x is an array
7169/// - &"123"[2] -> 0
7170/// - & __real__ x -> x
Douglas Gregor5251f1b2008-10-21 16:13:35 +00007171static NamedDecl *getPrimaryDecl(Expr *E) {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007172 switch (E->getStmtClass()) {
Steve Naroff47500512007-04-19 23:00:49 +00007173 case Stmt::DeclRefExprClass:
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007174 return cast<DeclRefExpr>(E)->getDecl();
Steve Naroff47500512007-04-19 23:00:49 +00007175 case Stmt::MemberExprClass:
Eli Friedman3a1e6922009-04-20 08:23:18 +00007176 // If this is an arrow operator, the address is an offset from
7177 // the base's value, so the object the base refers to is
7178 // irrelevant.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007179 if (cast<MemberExpr>(E)->isArrow())
Chris Lattner48d52842007-11-16 17:46:48 +00007180 return 0;
Eli Friedman3a1e6922009-04-20 08:23:18 +00007181 // Otherwise, the expression refers to a part of the base
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007182 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
Anders Carlsson806700f2008-02-01 07:15:58 +00007183 case Stmt::ArraySubscriptExprClass: {
Mike Stump87c57ac2009-05-16 07:39:55 +00007184 // FIXME: This code shouldn't be necessary! We should catch the implicit
7185 // promotion of register arrays earlier.
Eli Friedman3a1e6922009-04-20 08:23:18 +00007186 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
7187 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
7188 if (ICE->getSubExpr()->getType()->isArrayType())
7189 return getPrimaryDecl(ICE->getSubExpr());
7190 }
7191 return 0;
Anders Carlsson806700f2008-02-01 07:15:58 +00007192 }
Daniel Dunbarb692ef42008-08-04 20:02:37 +00007193 case Stmt::UnaryOperatorClass: {
7194 UnaryOperator *UO = cast<UnaryOperator>(E);
Mike Stump4e1f26a2009-02-19 03:04:26 +00007195
Daniel Dunbarb692ef42008-08-04 20:02:37 +00007196 switch(UO->getOpcode()) {
John McCalle3027922010-08-25 11:45:40 +00007197 case UO_Real:
7198 case UO_Imag:
7199 case UO_Extension:
Daniel Dunbarb692ef42008-08-04 20:02:37 +00007200 return getPrimaryDecl(UO->getSubExpr());
7201 default:
7202 return 0;
7203 }
7204 }
Steve Naroff47500512007-04-19 23:00:49 +00007205 case Stmt::ParenExprClass:
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007206 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
Chris Lattner48d52842007-11-16 17:46:48 +00007207 case Stmt::ImplicitCastExprClass:
Eli Friedman3a1e6922009-04-20 08:23:18 +00007208 // If the result of an implicit cast is an l-value, we care about
7209 // the sub-expression; otherwise, the result here doesn't matter.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00007210 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
Steve Naroff47500512007-04-19 23:00:49 +00007211 default:
7212 return 0;
7213 }
7214}
7215
7216/// CheckAddressOfOperand - The operand of & must be either a function
Mike Stump4e1f26a2009-02-19 03:04:26 +00007217/// designator or an lvalue designating an object. If it is an lvalue, the
Steve Naroff47500512007-04-19 23:00:49 +00007218/// object cannot be declared with storage class register or be a bit field.
Mike Stump4e1f26a2009-02-19 03:04:26 +00007219/// Note: The usual conversions are *not* applied to the operand of the &
Steve Naroffa78fe7e2007-05-16 19:47:19 +00007220/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
Mike Stump4e1f26a2009-02-19 03:04:26 +00007221/// In C++, the operand might be an overloaded function name, in which case
Douglas Gregorcd695e52008-11-10 20:40:00 +00007222/// we allow the '&' but retain the overloaded-function type.
John McCall4bc41ae2010-11-18 19:01:18 +00007223static QualType CheckAddressOfOperand(Sema &S, Expr *OrigOp,
7224 SourceLocation OpLoc) {
John McCall8d08b9b2010-08-27 09:08:28 +00007225 if (OrigOp->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00007226 return S.Context.DependentTy;
7227 if (OrigOp->getType() == S.Context.OverloadTy)
7228 return S.Context.OverloadTy;
John McCall8d08b9b2010-08-27 09:08:28 +00007229
John McCall4bc41ae2010-11-18 19:01:18 +00007230 ExprResult PR = S.CheckPlaceholderExpr(OrigOp, OpLoc);
John McCall36226622010-10-12 02:09:17 +00007231 if (PR.isInvalid()) return QualType();
7232 OrigOp = PR.take();
7233
John McCall8d08b9b2010-08-27 09:08:28 +00007234 // Make sure to ignore parentheses in subsequent checks
7235 Expr *op = OrigOp->IgnoreParens();
Douglas Gregor19b8c4f2008-12-17 22:52:20 +00007236
John McCall4bc41ae2010-11-18 19:01:18 +00007237 if (S.getLangOptions().C99) {
Steve Naroff826e91a2008-01-13 17:10:08 +00007238 // Implement C99-only parts of addressof rules.
7239 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
John McCalle3027922010-08-25 11:45:40 +00007240 if (uOp->getOpcode() == UO_Deref)
Steve Naroff826e91a2008-01-13 17:10:08 +00007241 // Per C99 6.5.3.2, the address of a deref always returns a valid result
7242 // (assuming the deref expression is valid).
7243 return uOp->getSubExpr()->getType();
7244 }
7245 // Technically, there should be a check for array subscript
7246 // expressions here, but the result of one is always an lvalue anyway.
7247 }
Douglas Gregor5251f1b2008-10-21 16:13:35 +00007248 NamedDecl *dcl = getPrimaryDecl(op);
John McCall086a4642010-11-24 05:12:34 +00007249 Expr::LValueClassification lval = op->ClassifyLValue(S.Context);
Nuno Lopes17f345f2008-12-16 22:59:47 +00007250
Chris Lattner9156f1b2010-07-05 19:17:26 +00007251 if (lval == Expr::LV_ClassTemporary) {
John McCall4bc41ae2010-11-18 19:01:18 +00007252 bool sfinae = S.isSFINAEContext();
7253 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary
7254 : diag::ext_typecheck_addrof_class_temporary)
Douglas Gregorb154fdc2010-02-16 21:39:57 +00007255 << op->getType() << op->getSourceRange();
John McCall4bc41ae2010-11-18 19:01:18 +00007256 if (sfinae)
Douglas Gregorb154fdc2010-02-16 21:39:57 +00007257 return QualType();
John McCall8d08b9b2010-08-27 09:08:28 +00007258 } else if (isa<ObjCSelectorExpr>(op)) {
John McCall4bc41ae2010-11-18 19:01:18 +00007259 return S.Context.getPointerType(op->getType());
John McCall8d08b9b2010-08-27 09:08:28 +00007260 } else if (lval == Expr::LV_MemberFunction) {
7261 // If it's an instance method, make a member pointer.
7262 // The expression must have exactly the form &A::foo.
7263
7264 // If the underlying expression isn't a decl ref, give up.
7265 if (!isa<DeclRefExpr>(op)) {
John McCall4bc41ae2010-11-18 19:01:18 +00007266 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
John McCall8d08b9b2010-08-27 09:08:28 +00007267 << OrigOp->getSourceRange();
7268 return QualType();
7269 }
7270 DeclRefExpr *DRE = cast<DeclRefExpr>(op);
7271 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
7272
7273 // The id-expression was parenthesized.
7274 if (OrigOp != DRE) {
John McCall4bc41ae2010-11-18 19:01:18 +00007275 S.Diag(OpLoc, diag::err_parens_pointer_member_function)
John McCall8d08b9b2010-08-27 09:08:28 +00007276 << OrigOp->getSourceRange();
7277
7278 // The method was named without a qualifier.
7279 } else if (!DRE->getQualifier()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007280 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function)
John McCall8d08b9b2010-08-27 09:08:28 +00007281 << op->getSourceRange();
7282 }
7283
John McCall4bc41ae2010-11-18 19:01:18 +00007284 return S.Context.getMemberPointerType(op->getType(),
7285 S.Context.getTypeDeclType(MD->getParent()).getTypePtr());
John McCall8d08b9b2010-08-27 09:08:28 +00007286 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
Eli Friedmance7f9002009-05-16 23:27:50 +00007287 // C99 6.5.3.2p1
Eli Friedman3a1e6922009-04-20 08:23:18 +00007288 // The operand must be either an l-value or a function designator
Eli Friedmance7f9002009-05-16 23:27:50 +00007289 if (!op->getType()->isFunctionType()) {
Chris Lattner48d52842007-11-16 17:46:48 +00007290 // FIXME: emit more specific diag...
John McCall4bc41ae2010-11-18 19:01:18 +00007291 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
Chris Lattnerf490e152008-11-19 05:27:50 +00007292 << op->getSourceRange();
Steve Naroff35d85152007-05-07 00:24:15 +00007293 return QualType();
7294 }
John McCall086a4642010-11-24 05:12:34 +00007295 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1
Eli Friedman3a1e6922009-04-20 08:23:18 +00007296 // The operand cannot be a bit-field
John McCall4bc41ae2010-11-18 19:01:18 +00007297 S.Diag(OpLoc, diag::err_typecheck_address_of)
Eli Friedman3a1e6922009-04-20 08:23:18 +00007298 << "bit-field" << op->getSourceRange();
Douglas Gregor2eedc3a2008-12-20 23:49:58 +00007299 return QualType();
John McCall086a4642010-11-24 05:12:34 +00007300 } else if (op->getObjectKind() == OK_VectorComponent) {
Eli Friedman3a1e6922009-04-20 08:23:18 +00007301 // The operand cannot be an element of a vector
John McCall4bc41ae2010-11-18 19:01:18 +00007302 S.Diag(OpLoc, diag::err_typecheck_address_of)
Nate Begemana6b47a42009-02-15 22:45:20 +00007303 << "vector element" << op->getSourceRange();
Steve Naroffb96e4ab62008-02-29 23:30:25 +00007304 return QualType();
John McCall086a4642010-11-24 05:12:34 +00007305 } else if (op->getObjectKind() == OK_ObjCProperty) {
Fariborz Jahanian385db802009-07-07 18:50:52 +00007306 // cannot take address of a property expression.
John McCall4bc41ae2010-11-18 19:01:18 +00007307 S.Diag(OpLoc, diag::err_typecheck_address_of)
Fariborz Jahanian385db802009-07-07 18:50:52 +00007308 << "property expression" << op->getSourceRange();
7309 return QualType();
Steve Naroffb96e4ab62008-02-29 23:30:25 +00007310 } else if (dcl) { // C99 6.5.3.2p1
Mike Stump4e1f26a2009-02-19 03:04:26 +00007311 // We have an lvalue with a decl. Make sure the decl is not declared
Steve Naroff47500512007-04-19 23:00:49 +00007312 // with the register storage-class specifier.
7313 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
Fariborz Jahaniane0fd5a92010-08-24 22:21:48 +00007314 // in C++ it is not error to take address of a register
7315 // variable (c++03 7.1.1P3)
John McCall8e7d6562010-08-26 03:08:43 +00007316 if (vd->getStorageClass() == SC_Register &&
John McCall4bc41ae2010-11-18 19:01:18 +00007317 !S.getLangOptions().CPlusPlus) {
7318 S.Diag(OpLoc, diag::err_typecheck_address_of)
Chris Lattner29e812b2008-11-20 06:06:08 +00007319 << "register variable" << op->getSourceRange();
Steve Naroff35d85152007-05-07 00:24:15 +00007320 return QualType();
7321 }
John McCalld14a8642009-11-21 08:51:07 +00007322 } else if (isa<FunctionTemplateDecl>(dcl)) {
John McCall4bc41ae2010-11-18 19:01:18 +00007323 return S.Context.OverloadTy;
Anders Carlsson0b675f52009-07-08 21:45:58 +00007324 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(dcl)) {
Douglas Gregor9aa8b552008-12-10 21:26:49 +00007325 // Okay: we can take the address of a field.
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00007326 // Could be a pointer to member, though, if there is an explicit
7327 // scope qualifier for the class.
Douglas Gregor4bd90e52009-10-23 18:54:35 +00007328 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00007329 DeclContext *Ctx = dcl->getDeclContext();
Anders Carlsson0b675f52009-07-08 21:45:58 +00007330 if (Ctx && Ctx->isRecord()) {
7331 if (FD->getType()->isReferenceType()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007332 S.Diag(OpLoc,
7333 diag::err_cannot_form_pointer_to_member_of_reference_type)
Anders Carlsson0b675f52009-07-08 21:45:58 +00007334 << FD->getDeclName() << FD->getType();
7335 return QualType();
7336 }
Mike Stump11289f42009-09-09 15:08:12 +00007337
John McCall4bc41ae2010-11-18 19:01:18 +00007338 return S.Context.getMemberPointerType(op->getType(),
7339 S.Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
Anders Carlsson0b675f52009-07-08 21:45:58 +00007340 }
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00007341 }
Anders Carlsson5b535762009-05-16 21:43:42 +00007342 } else if (!isa<FunctionDecl>(dcl))
Steve Narofff633d092007-04-25 19:01:39 +00007343 assert(0 && "Unknown/unexpected decl type");
Steve Naroff47500512007-04-19 23:00:49 +00007344 }
Sebastian Redl18f8ff62009-02-04 21:23:32 +00007345
Eli Friedmance7f9002009-05-16 23:27:50 +00007346 if (lval == Expr::LV_IncompleteVoidType) {
7347 // Taking the address of a void variable is technically illegal, but we
7348 // allow it in cases which are otherwise valid.
7349 // Example: "extern void x; void* y = &x;".
John McCall4bc41ae2010-11-18 19:01:18 +00007350 S.Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
Eli Friedmance7f9002009-05-16 23:27:50 +00007351 }
7352
Steve Naroff47500512007-04-19 23:00:49 +00007353 // If the operand has type "type", the result has type "pointer to type".
Douglas Gregor0bdcb8a2010-07-29 16:05:45 +00007354 if (op->getType()->isObjCObjectType())
John McCall4bc41ae2010-11-18 19:01:18 +00007355 return S.Context.getObjCObjectPointerType(op->getType());
7356 return S.Context.getPointerType(op->getType());
Steve Naroff47500512007-04-19 23:00:49 +00007357}
7358
Chris Lattner9156f1b2010-07-05 19:17:26 +00007359/// CheckIndirectionOperand - Type check unary indirection (prefix '*').
John McCall4bc41ae2010-11-18 19:01:18 +00007360static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
7361 SourceLocation OpLoc) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007362 if (Op->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00007363 return S.Context.DependentTy;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007364
John McCall4bc41ae2010-11-18 19:01:18 +00007365 S.UsualUnaryConversions(Op);
Chris Lattner9156f1b2010-07-05 19:17:26 +00007366 QualType OpTy = Op->getType();
7367 QualType Result;
7368
7369 // Note that per both C89 and C99, indirection is always legal, even if OpTy
7370 // is an incomplete type or void. It would be possible to warn about
7371 // dereferencing a void pointer, but it's completely well-defined, and such a
7372 // warning is unlikely to catch any mistakes.
7373 if (const PointerType *PT = OpTy->getAs<PointerType>())
7374 Result = PT->getPointeeType();
7375 else if (const ObjCObjectPointerType *OPT =
7376 OpTy->getAs<ObjCObjectPointerType>())
7377 Result = OPT->getPointeeType();
John McCall36226622010-10-12 02:09:17 +00007378 else {
John McCall4bc41ae2010-11-18 19:01:18 +00007379 ExprResult PR = S.CheckPlaceholderExpr(Op, OpLoc);
John McCall36226622010-10-12 02:09:17 +00007380 if (PR.isInvalid()) return QualType();
John McCall4bc41ae2010-11-18 19:01:18 +00007381 if (PR.take() != Op)
7382 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc);
John McCall36226622010-10-12 02:09:17 +00007383 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007384
Chris Lattner9156f1b2010-07-05 19:17:26 +00007385 if (Result.isNull()) {
John McCall4bc41ae2010-11-18 19:01:18 +00007386 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
Chris Lattner9156f1b2010-07-05 19:17:26 +00007387 << OpTy << Op->getSourceRange();
7388 return QualType();
7389 }
John McCall4bc41ae2010-11-18 19:01:18 +00007390
7391 // Dereferences are usually l-values...
7392 VK = VK_LValue;
7393
7394 // ...except that certain expressions are never l-values in C.
7395 if (!S.getLangOptions().CPlusPlus &&
7396 IsCForbiddenLValueType(S.Context, Result))
7397 VK = VK_RValue;
Chris Lattner9156f1b2010-07-05 19:17:26 +00007398
7399 return Result;
Steve Naroff1926c832007-04-24 00:23:05 +00007400}
Steve Naroff218bc2b2007-05-04 21:54:46 +00007401
John McCalle3027922010-08-25 11:45:40 +00007402static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode(
Steve Naroff218bc2b2007-05-04 21:54:46 +00007403 tok::TokenKind Kind) {
John McCalle3027922010-08-25 11:45:40 +00007404 BinaryOperatorKind Opc;
Steve Naroff218bc2b2007-05-04 21:54:46 +00007405 switch (Kind) {
7406 default: assert(0 && "Unknown binop!");
John McCalle3027922010-08-25 11:45:40 +00007407 case tok::periodstar: Opc = BO_PtrMemD; break;
7408 case tok::arrowstar: Opc = BO_PtrMemI; break;
7409 case tok::star: Opc = BO_Mul; break;
7410 case tok::slash: Opc = BO_Div; break;
7411 case tok::percent: Opc = BO_Rem; break;
7412 case tok::plus: Opc = BO_Add; break;
7413 case tok::minus: Opc = BO_Sub; break;
7414 case tok::lessless: Opc = BO_Shl; break;
7415 case tok::greatergreater: Opc = BO_Shr; break;
7416 case tok::lessequal: Opc = BO_LE; break;
7417 case tok::less: Opc = BO_LT; break;
7418 case tok::greaterequal: Opc = BO_GE; break;
7419 case tok::greater: Opc = BO_GT; break;
7420 case tok::exclaimequal: Opc = BO_NE; break;
7421 case tok::equalequal: Opc = BO_EQ; break;
7422 case tok::amp: Opc = BO_And; break;
7423 case tok::caret: Opc = BO_Xor; break;
7424 case tok::pipe: Opc = BO_Or; break;
7425 case tok::ampamp: Opc = BO_LAnd; break;
7426 case tok::pipepipe: Opc = BO_LOr; break;
7427 case tok::equal: Opc = BO_Assign; break;
7428 case tok::starequal: Opc = BO_MulAssign; break;
7429 case tok::slashequal: Opc = BO_DivAssign; break;
7430 case tok::percentequal: Opc = BO_RemAssign; break;
7431 case tok::plusequal: Opc = BO_AddAssign; break;
7432 case tok::minusequal: Opc = BO_SubAssign; break;
7433 case tok::lesslessequal: Opc = BO_ShlAssign; break;
7434 case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
7435 case tok::ampequal: Opc = BO_AndAssign; break;
7436 case tok::caretequal: Opc = BO_XorAssign; break;
7437 case tok::pipeequal: Opc = BO_OrAssign; break;
7438 case tok::comma: Opc = BO_Comma; break;
Steve Naroff218bc2b2007-05-04 21:54:46 +00007439 }
7440 return Opc;
7441}
7442
John McCalle3027922010-08-25 11:45:40 +00007443static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
Steve Naroff35d85152007-05-07 00:24:15 +00007444 tok::TokenKind Kind) {
John McCalle3027922010-08-25 11:45:40 +00007445 UnaryOperatorKind Opc;
Steve Naroff35d85152007-05-07 00:24:15 +00007446 switch (Kind) {
7447 default: assert(0 && "Unknown unary op!");
John McCalle3027922010-08-25 11:45:40 +00007448 case tok::plusplus: Opc = UO_PreInc; break;
7449 case tok::minusminus: Opc = UO_PreDec; break;
7450 case tok::amp: Opc = UO_AddrOf; break;
7451 case tok::star: Opc = UO_Deref; break;
7452 case tok::plus: Opc = UO_Plus; break;
7453 case tok::minus: Opc = UO_Minus; break;
7454 case tok::tilde: Opc = UO_Not; break;
7455 case tok::exclaim: Opc = UO_LNot; break;
7456 case tok::kw___real: Opc = UO_Real; break;
7457 case tok::kw___imag: Opc = UO_Imag; break;
7458 case tok::kw___extension__: Opc = UO_Extension; break;
Steve Naroff35d85152007-05-07 00:24:15 +00007459 }
7460 return Opc;
7461}
7462
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007463/// CreateBuiltinBinOp - Creates a new built-in binary operation with
7464/// operator @p Opc at location @c TokLoc. This routine only supports
7465/// built-in operations; ActOnBinOp handles overloaded operators.
John McCalldadc5752010-08-24 06:29:42 +00007466ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
John McCalle3027922010-08-25 11:45:40 +00007467 unsigned Op,
7468 Expr *lhs, Expr *rhs) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007469 QualType ResultTy; // Result type of the binary operator.
John McCalle3027922010-08-25 11:45:40 +00007470 BinaryOperatorKind Opc = (BinaryOperatorKind) Op;
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007471 // The following two variables are used for compound assignment operators
7472 QualType CompLHSTy; // Type of LHS after promotions for computation
7473 QualType CompResultTy; // Type of computation result
John McCall7decc9e2010-11-18 06:31:45 +00007474 ExprValueKind VK = VK_RValue;
7475 ExprObjectKind OK = OK_Ordinary;
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007476
7477 switch (Opc) {
John McCalle3027922010-08-25 11:45:40 +00007478 case BO_Assign:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007479 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType());
John McCall34376a62010-12-04 03:47:34 +00007480 if (getLangOptions().CPlusPlus &&
7481 lhs->getObjectKind() != OK_ObjCProperty) {
John McCall4bc41ae2010-11-18 19:01:18 +00007482 VK = lhs->getValueKind();
7483 OK = lhs->getObjectKind();
John McCall7decc9e2010-11-18 06:31:45 +00007484 }
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007485 break;
John McCalle3027922010-08-25 11:45:40 +00007486 case BO_PtrMemD:
7487 case BO_PtrMemI:
John McCall7decc9e2010-11-18 06:31:45 +00007488 ResultTy = CheckPointerToMemberOperands(lhs, rhs, VK, OpLoc,
John McCalle3027922010-08-25 11:45:40 +00007489 Opc == BO_PtrMemI);
Sebastian Redl112a97662009-02-07 00:15:38 +00007490 break;
John McCalle3027922010-08-25 11:45:40 +00007491 case BO_Mul:
7492 case BO_Div:
Chris Lattnerfaa54172010-01-12 21:23:57 +00007493 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, false,
John McCalle3027922010-08-25 11:45:40 +00007494 Opc == BO_Div);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007495 break;
John McCalle3027922010-08-25 11:45:40 +00007496 case BO_Rem:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007497 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc);
7498 break;
John McCalle3027922010-08-25 11:45:40 +00007499 case BO_Add:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007500 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc);
7501 break;
John McCalle3027922010-08-25 11:45:40 +00007502 case BO_Sub:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007503 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc);
7504 break;
John McCalle3027922010-08-25 11:45:40 +00007505 case BO_Shl:
7506 case BO_Shr:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007507 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc);
7508 break;
John McCalle3027922010-08-25 11:45:40 +00007509 case BO_LE:
7510 case BO_LT:
7511 case BO_GE:
7512 case BO_GT:
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007513 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007514 break;
John McCalle3027922010-08-25 11:45:40 +00007515 case BO_EQ:
7516 case BO_NE:
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007517 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007518 break;
John McCalle3027922010-08-25 11:45:40 +00007519 case BO_And:
7520 case BO_Xor:
7521 case BO_Or:
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007522 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc);
7523 break;
John McCalle3027922010-08-25 11:45:40 +00007524 case BO_LAnd:
7525 case BO_LOr:
Chris Lattner8406c512010-07-13 19:41:32 +00007526 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc, Opc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007527 break;
John McCalle3027922010-08-25 11:45:40 +00007528 case BO_MulAssign:
7529 case BO_DivAssign:
Chris Lattnerfaa54172010-01-12 21:23:57 +00007530 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true,
John McCall7decc9e2010-11-18 06:31:45 +00007531 Opc == BO_DivAssign);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007532 CompLHSTy = CompResultTy;
7533 if (!CompResultTy.isNull())
7534 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007535 break;
John McCalle3027922010-08-25 11:45:40 +00007536 case BO_RemAssign:
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007537 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true);
7538 CompLHSTy = CompResultTy;
7539 if (!CompResultTy.isNull())
7540 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007541 break;
John McCalle3027922010-08-25 11:45:40 +00007542 case BO_AddAssign:
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007543 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy);
7544 if (!CompResultTy.isNull())
7545 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007546 break;
John McCalle3027922010-08-25 11:45:40 +00007547 case BO_SubAssign:
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007548 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy);
7549 if (!CompResultTy.isNull())
7550 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007551 break;
John McCalle3027922010-08-25 11:45:40 +00007552 case BO_ShlAssign:
7553 case BO_ShrAssign:
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007554 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true);
7555 CompLHSTy = CompResultTy;
7556 if (!CompResultTy.isNull())
7557 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007558 break;
John McCalle3027922010-08-25 11:45:40 +00007559 case BO_AndAssign:
7560 case BO_XorAssign:
7561 case BO_OrAssign:
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007562 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true);
7563 CompLHSTy = CompResultTy;
7564 if (!CompResultTy.isNull())
7565 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007566 break;
John McCalle3027922010-08-25 11:45:40 +00007567 case BO_Comma:
John McCall4bc41ae2010-11-18 19:01:18 +00007568 ResultTy = CheckCommaOperands(*this, lhs, rhs, OpLoc);
John McCall7decc9e2010-11-18 06:31:45 +00007569 if (getLangOptions().CPlusPlus) {
7570 VK = rhs->getValueKind();
7571 OK = rhs->getObjectKind();
7572 }
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007573 break;
7574 }
7575 if (ResultTy.isNull())
Sebastian Redlb5d49352009-01-19 22:31:54 +00007576 return ExprError();
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007577 if (CompResultTy.isNull())
John McCall7decc9e2010-11-18 06:31:45 +00007578 return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy,
7579 VK, OK, OpLoc));
7580
John McCall34376a62010-12-04 03:47:34 +00007581 if (getLangOptions().CPlusPlus && lhs->getObjectKind() != OK_ObjCProperty) {
John McCall7decc9e2010-11-18 06:31:45 +00007582 VK = VK_LValue;
7583 OK = lhs->getObjectKind();
7584 }
7585 return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy,
7586 VK, OK, CompLHSTy,
7587 CompResultTy, OpLoc));
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007588}
7589
Sebastian Redl44615072009-10-27 12:10:02 +00007590/// SuggestParentheses - Emit a diagnostic together with a fixit hint that wraps
7591/// ParenRange in parentheses.
Sebastian Redl4afb7c582009-10-26 17:01:32 +00007592static void SuggestParentheses(Sema &Self, SourceLocation Loc,
7593 const PartialDiagnostic &PD,
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007594 const PartialDiagnostic &FirstNote,
7595 SourceRange FirstParenRange,
7596 const PartialDiagnostic &SecondNote,
Douglas Gregor89336232010-03-29 23:34:08 +00007597 SourceRange SecondParenRange) {
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007598 Self.Diag(Loc, PD);
7599
7600 if (!FirstNote.getDiagID())
7601 return;
7602
7603 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(FirstParenRange.getEnd());
7604 if (!FirstParenRange.getEnd().isFileID() || EndLoc.isInvalid()) {
7605 // We can't display the parentheses, so just return.
Sebastian Redl4afb7c582009-10-26 17:01:32 +00007606 return;
7607 }
7608
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007609 Self.Diag(Loc, FirstNote)
7610 << FixItHint::CreateInsertion(FirstParenRange.getBegin(), "(")
Douglas Gregora771f462010-03-31 17:46:05 +00007611 << FixItHint::CreateInsertion(EndLoc, ")");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007612
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007613 if (!SecondNote.getDiagID())
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00007614 return;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007615
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00007616 EndLoc = Self.PP.getLocForEndOfToken(SecondParenRange.getEnd());
7617 if (!SecondParenRange.getEnd().isFileID() || EndLoc.isInvalid()) {
7618 // We can't display the parentheses, so just dig the
7619 // warning/error and return.
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007620 Self.Diag(Loc, SecondNote);
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00007621 return;
7622 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007623
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007624 Self.Diag(Loc, SecondNote)
Douglas Gregora771f462010-03-31 17:46:05 +00007625 << FixItHint::CreateInsertion(SecondParenRange.getBegin(), "(")
7626 << FixItHint::CreateInsertion(EndLoc, ")");
Sebastian Redl4afb7c582009-10-26 17:01:32 +00007627}
7628
Sebastian Redl44615072009-10-27 12:10:02 +00007629/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
7630/// operators are mixed in a way that suggests that the programmer forgot that
7631/// comparison operators have higher precedence. The most typical example of
7632/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
John McCalle3027922010-08-25 11:45:40 +00007633static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
Sebastian Redl43028242009-10-26 15:24:15 +00007634 SourceLocation OpLoc,Expr *lhs,Expr *rhs){
Sebastian Redl44615072009-10-27 12:10:02 +00007635 typedef BinaryOperator BinOp;
7636 BinOp::Opcode lhsopc = static_cast<BinOp::Opcode>(-1),
7637 rhsopc = static_cast<BinOp::Opcode>(-1);
7638 if (BinOp *BO = dyn_cast<BinOp>(lhs))
Sebastian Redl43028242009-10-26 15:24:15 +00007639 lhsopc = BO->getOpcode();
Sebastian Redl44615072009-10-27 12:10:02 +00007640 if (BinOp *BO = dyn_cast<BinOp>(rhs))
Sebastian Redl43028242009-10-26 15:24:15 +00007641 rhsopc = BO->getOpcode();
7642
7643 // Subs are not binary operators.
7644 if (lhsopc == -1 && rhsopc == -1)
7645 return;
7646
7647 // Bitwise operations are sometimes used as eager logical ops.
7648 // Don't diagnose this.
Sebastian Redl44615072009-10-27 12:10:02 +00007649 if ((BinOp::isComparisonOp(lhsopc) || BinOp::isBitwiseOp(lhsopc)) &&
7650 (BinOp::isComparisonOp(rhsopc) || BinOp::isBitwiseOp(rhsopc)))
Sebastian Redl43028242009-10-26 15:24:15 +00007651 return;
7652
Sebastian Redl44615072009-10-27 12:10:02 +00007653 if (BinOp::isComparisonOp(lhsopc))
Sebastian Redl4afb7c582009-10-26 17:01:32 +00007654 SuggestParentheses(Self, OpLoc,
Douglas Gregor89336232010-03-29 23:34:08 +00007655 Self.PDiag(diag::warn_precedence_bitwise_rel)
Sebastian Redl44615072009-10-27 12:10:02 +00007656 << SourceRange(lhs->getLocStart(), OpLoc)
7657 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(lhsopc),
Douglas Gregor89336232010-03-29 23:34:08 +00007658 Self.PDiag(diag::note_precedence_bitwise_first)
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00007659 << BinOp::getOpcodeStr(Opc),
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007660 SourceRange(cast<BinOp>(lhs)->getRHS()->getLocStart(), rhs->getLocEnd()),
7661 Self.PDiag(diag::note_precedence_bitwise_silence)
7662 << BinOp::getOpcodeStr(lhsopc),
7663 lhs->getSourceRange());
Sebastian Redl44615072009-10-27 12:10:02 +00007664 else if (BinOp::isComparisonOp(rhsopc))
Sebastian Redl4afb7c582009-10-26 17:01:32 +00007665 SuggestParentheses(Self, OpLoc,
Douglas Gregor89336232010-03-29 23:34:08 +00007666 Self.PDiag(diag::warn_precedence_bitwise_rel)
Sebastian Redl44615072009-10-27 12:10:02 +00007667 << SourceRange(OpLoc, rhs->getLocEnd())
7668 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(rhsopc),
Douglas Gregor89336232010-03-29 23:34:08 +00007669 Self.PDiag(diag::note_precedence_bitwise_first)
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00007670 << BinOp::getOpcodeStr(Opc),
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00007671 SourceRange(lhs->getLocEnd(), cast<BinOp>(rhs)->getLHS()->getLocStart()),
7672 Self.PDiag(diag::note_precedence_bitwise_silence)
7673 << BinOp::getOpcodeStr(rhsopc),
7674 rhs->getSourceRange());
Sebastian Redl43028242009-10-26 15:24:15 +00007675}
7676
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007677/// \brief It accepts a '&&' expr that is inside a '||' one.
7678/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
7679/// in parentheses.
7680static void
7681EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
7682 Expr *E) {
7683 assert(isa<BinaryOperator>(E) &&
7684 cast<BinaryOperator>(E)->getOpcode() == BO_LAnd);
7685 SuggestParentheses(Self, OpLoc,
7686 Self.PDiag(diag::warn_logical_and_in_logical_or)
7687 << E->getSourceRange(),
7688 Self.PDiag(diag::note_logical_and_in_logical_or_silence),
7689 E->getSourceRange(),
7690 Self.PDiag(0), SourceRange());
7691}
7692
7693/// \brief Returns true if the given expression can be evaluated as a constant
7694/// 'true'.
7695static bool EvaluatesAsTrue(Sema &S, Expr *E) {
7696 bool Res;
7697 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res;
7698}
7699
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007700/// \brief Returns true if the given expression can be evaluated as a constant
7701/// 'false'.
7702static bool EvaluatesAsFalse(Sema &S, Expr *E) {
7703 bool Res;
7704 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
7705}
7706
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007707/// \brief Look for '&&' in the left hand of a '||' expr.
7708static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc,
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007709 Expr *OrLHS, Expr *OrRHS) {
7710 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrLHS)) {
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007711 if (Bop->getOpcode() == BO_LAnd) {
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007712 // If it's "a && b || 0" don't warn since the precedence doesn't matter.
7713 if (EvaluatesAsFalse(S, OrRHS))
7714 return;
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007715 // If it's "1 && a || b" don't warn since the precedence doesn't matter.
7716 if (!EvaluatesAsTrue(S, Bop->getLHS()))
7717 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
7718 } else if (Bop->getOpcode() == BO_LOr) {
7719 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
7720 // If it's "a || b && 1 || c" we didn't warn earlier for
7721 // "a || b && 1", but warn now.
7722 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS()))
7723 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
7724 }
7725 }
7726 }
7727}
7728
7729/// \brief Look for '&&' in the right hand of a '||' expr.
7730static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc,
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007731 Expr *OrLHS, Expr *OrRHS) {
7732 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrRHS)) {
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007733 if (Bop->getOpcode() == BO_LAnd) {
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007734 // If it's "0 || a && b" don't warn since the precedence doesn't matter.
7735 if (EvaluatesAsFalse(S, OrLHS))
7736 return;
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007737 // If it's "a || b && 1" don't warn since the precedence doesn't matter.
7738 if (!EvaluatesAsTrue(S, Bop->getRHS()))
7739 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007740 }
7741 }
7742}
7743
Sebastian Redl43028242009-10-26 15:24:15 +00007744/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007745/// precedence.
John McCalle3027922010-08-25 11:45:40 +00007746static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
Sebastian Redl43028242009-10-26 15:24:15 +00007747 SourceLocation OpLoc, Expr *lhs, Expr *rhs){
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007748 // Diagnose "arg1 'bitwise' arg2 'eq' arg3".
Sebastian Redl44615072009-10-27 12:10:02 +00007749 if (BinaryOperator::isBitwiseOp(Opc))
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007750 return DiagnoseBitwisePrecedence(Self, Opc, OpLoc, lhs, rhs);
7751
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00007752 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
7753 // We don't warn for 'assert(a || b && "bad")' since this is safe.
Argyrios Kyrtzidisb94e5a32010-11-17 18:54:22 +00007754 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00007755 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, lhs, rhs);
7756 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, lhs, rhs);
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00007757 }
Sebastian Redl43028242009-10-26 15:24:15 +00007758}
7759
Steve Naroff218bc2b2007-05-04 21:54:46 +00007760// Binary Operators. 'Tok' is the token for the operator.
John McCalldadc5752010-08-24 06:29:42 +00007761ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
John McCalle3027922010-08-25 11:45:40 +00007762 tok::TokenKind Kind,
7763 Expr *lhs, Expr *rhs) {
7764 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
Steve Naroff83895f72007-09-16 03:34:24 +00007765 assert((lhs != 0) && "ActOnBinOp(): missing left expression");
7766 assert((rhs != 0) && "ActOnBinOp(): missing right expression");
Steve Naroff218bc2b2007-05-04 21:54:46 +00007767
Sebastian Redl43028242009-10-26 15:24:15 +00007768 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
7769 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, lhs, rhs);
7770
Douglas Gregor5287f092009-11-05 00:51:44 +00007771 return BuildBinOp(S, TokLoc, Opc, lhs, rhs);
7772}
7773
John McCalldadc5752010-08-24 06:29:42 +00007774ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
John McCalle3027922010-08-25 11:45:40 +00007775 BinaryOperatorKind Opc,
7776 Expr *lhs, Expr *rhs) {
John McCall622114c2010-12-06 05:26:58 +00007777 if (getLangOptions().CPlusPlus) {
7778 bool UseBuiltinOperator;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007779
John McCall622114c2010-12-06 05:26:58 +00007780 if (lhs->isTypeDependent() || rhs->isTypeDependent()) {
7781 UseBuiltinOperator = false;
7782 } else if (Opc == BO_Assign && lhs->getObjectKind() == OK_ObjCProperty) {
7783 UseBuiltinOperator = true;
7784 } else {
7785 UseBuiltinOperator = !lhs->getType()->isOverloadableType() &&
7786 !rhs->getType()->isOverloadableType();
7787 }
7788
7789 if (!UseBuiltinOperator) {
7790 // Find all of the overloaded operators visible from this
7791 // point. We perform both an operator-name lookup from the local
7792 // scope and an argument-dependent lookup based on the types of
7793 // the arguments.
7794 UnresolvedSet<16> Functions;
7795 OverloadedOperatorKind OverOp
7796 = BinaryOperator::getOverloadedOperator(Opc);
7797 if (S && OverOp != OO_None)
7798 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(),
7799 Functions);
7800
7801 // Build the (potentially-overloaded, potentially-dependent)
7802 // binary operation.
7803 return CreateOverloadedBinOp(OpLoc, Opc, Functions, lhs, rhs);
7804 }
Sebastian Redlb5d49352009-01-19 22:31:54 +00007805 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007806
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00007807 // Build a built-in binary operation.
Douglas Gregor5287f092009-11-05 00:51:44 +00007808 return CreateBuiltinBinOp(OpLoc, Opc, lhs, rhs);
Steve Naroff218bc2b2007-05-04 21:54:46 +00007809}
7810
John McCalldadc5752010-08-24 06:29:42 +00007811ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
John McCall36226622010-10-12 02:09:17 +00007812 unsigned OpcIn,
7813 Expr *Input) {
John McCalle3027922010-08-25 11:45:40 +00007814 UnaryOperatorKind Opc = static_cast<UnaryOperatorKind>(OpcIn);
Douglas Gregord08452f2008-11-19 15:42:04 +00007815
John McCall7decc9e2010-11-18 06:31:45 +00007816 ExprValueKind VK = VK_RValue;
7817 ExprObjectKind OK = OK_Ordinary;
Steve Naroff35d85152007-05-07 00:24:15 +00007818 QualType resultType;
7819 switch (Opc) {
John McCalle3027922010-08-25 11:45:40 +00007820 case UO_PreInc:
7821 case UO_PreDec:
7822 case UO_PostInc:
7823 case UO_PostDec:
John McCall4bc41ae2010-11-18 19:01:18 +00007824 resultType = CheckIncrementDecrementOperand(*this, Input, VK, OpLoc,
John McCalle3027922010-08-25 11:45:40 +00007825 Opc == UO_PreInc ||
7826 Opc == UO_PostInc,
7827 Opc == UO_PreInc ||
7828 Opc == UO_PreDec);
Steve Naroff35d85152007-05-07 00:24:15 +00007829 break;
John McCalle3027922010-08-25 11:45:40 +00007830 case UO_AddrOf:
John McCall4bc41ae2010-11-18 19:01:18 +00007831 resultType = CheckAddressOfOperand(*this, Input, OpLoc);
Steve Naroff35d85152007-05-07 00:24:15 +00007832 break;
John McCalle3027922010-08-25 11:45:40 +00007833 case UO_Deref:
Douglas Gregorb92a1562010-02-03 00:27:59 +00007834 DefaultFunctionArrayLvalueConversion(Input);
John McCall4bc41ae2010-11-18 19:01:18 +00007835 resultType = CheckIndirectionOperand(*this, Input, VK, OpLoc);
Steve Naroff35d85152007-05-07 00:24:15 +00007836 break;
John McCalle3027922010-08-25 11:45:40 +00007837 case UO_Plus:
7838 case UO_Minus:
Steve Naroff31090012007-07-16 21:54:35 +00007839 UsualUnaryConversions(Input);
7840 resultType = Input->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007841 if (resultType->isDependentType())
7842 break;
Douglas Gregora3208f92010-06-22 23:41:02 +00007843 if (resultType->isArithmeticType() || // C99 6.5.3.3p1
7844 resultType->isVectorType())
Douglas Gregord08452f2008-11-19 15:42:04 +00007845 break;
7846 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7
7847 resultType->isEnumeralType())
7848 break;
7849 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6
John McCalle3027922010-08-25 11:45:40 +00007850 Opc == UO_Plus &&
Douglas Gregord08452f2008-11-19 15:42:04 +00007851 resultType->isPointerType())
7852 break;
John McCall36226622010-10-12 02:09:17 +00007853 else if (resultType->isPlaceholderType()) {
7854 ExprResult PR = CheckPlaceholderExpr(Input, OpLoc);
7855 if (PR.isInvalid()) return ExprError();
7856 return CreateBuiltinUnaryOp(OpLoc, OpcIn, PR.take());
7857 }
Douglas Gregord08452f2008-11-19 15:42:04 +00007858
Sebastian Redlc215cfc2009-01-19 00:08:26 +00007859 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
7860 << resultType << Input->getSourceRange());
John McCalle3027922010-08-25 11:45:40 +00007861 case UO_Not: // bitwise complement
Steve Naroff31090012007-07-16 21:54:35 +00007862 UsualUnaryConversions(Input);
7863 resultType = Input->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007864 if (resultType->isDependentType())
7865 break;
Chris Lattner0d707612008-07-25 23:52:49 +00007866 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
7867 if (resultType->isComplexType() || resultType->isComplexIntegerType())
7868 // C99 does not support '~' for complex conjugation.
Chris Lattner29e812b2008-11-20 06:06:08 +00007869 Diag(OpLoc, diag::ext_integer_complement_complex)
Chris Lattner1e5665e2008-11-24 06:25:27 +00007870 << resultType << Input->getSourceRange();
John McCall36226622010-10-12 02:09:17 +00007871 else if (resultType->hasIntegerRepresentation())
7872 break;
7873 else if (resultType->isPlaceholderType()) {
7874 ExprResult PR = CheckPlaceholderExpr(Input, OpLoc);
7875 if (PR.isInvalid()) return ExprError();
7876 return CreateBuiltinUnaryOp(OpLoc, OpcIn, PR.take());
7877 } else {
Sebastian Redlc215cfc2009-01-19 00:08:26 +00007878 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
7879 << resultType << Input->getSourceRange());
John McCall36226622010-10-12 02:09:17 +00007880 }
Steve Naroff35d85152007-05-07 00:24:15 +00007881 break;
John McCalle3027922010-08-25 11:45:40 +00007882 case UO_LNot: // logical negation
Steve Naroff71b59a92007-06-04 22:22:31 +00007883 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
Douglas Gregorb92a1562010-02-03 00:27:59 +00007884 DefaultFunctionArrayLvalueConversion(Input);
Steve Naroff31090012007-07-16 21:54:35 +00007885 resultType = Input->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00007886 if (resultType->isDependentType())
7887 break;
John McCall36226622010-10-12 02:09:17 +00007888 if (resultType->isScalarType()) { // C99 6.5.3.3p1
7889 // ok, fallthrough
7890 } else if (resultType->isPlaceholderType()) {
7891 ExprResult PR = CheckPlaceholderExpr(Input, OpLoc);
7892 if (PR.isInvalid()) return ExprError();
7893 return CreateBuiltinUnaryOp(OpLoc, OpcIn, PR.take());
7894 } else {
Sebastian Redlc215cfc2009-01-19 00:08:26 +00007895 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
7896 << resultType << Input->getSourceRange());
John McCall36226622010-10-12 02:09:17 +00007897 }
Douglas Gregordb8c6fd2010-09-20 17:13:33 +00007898
Chris Lattnerbe31ed82007-06-02 19:11:33 +00007899 // LNot always has type int. C99 6.5.3.3p5.
Sebastian Redlc215cfc2009-01-19 00:08:26 +00007900 // In C++, it's bool. C++ 5.3.1p8
7901 resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy;
Steve Naroff35d85152007-05-07 00:24:15 +00007902 break;
John McCalle3027922010-08-25 11:45:40 +00007903 case UO_Real:
7904 case UO_Imag:
John McCall4bc41ae2010-11-18 19:01:18 +00007905 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real);
John McCall7decc9e2010-11-18 06:31:45 +00007906 // _Real and _Imag map ordinary l-values into ordinary l-values.
7907 if (Input->getValueKind() != VK_RValue &&
7908 Input->getObjectKind() == OK_Ordinary)
7909 VK = Input->getValueKind();
Chris Lattner30b5dd02007-08-24 21:16:53 +00007910 break;
John McCalle3027922010-08-25 11:45:40 +00007911 case UO_Extension:
Chris Lattner86554282007-06-08 22:32:33 +00007912 resultType = Input->getType();
John McCall7decc9e2010-11-18 06:31:45 +00007913 VK = Input->getValueKind();
7914 OK = Input->getObjectKind();
Steve Naroff043d45d2007-05-15 02:32:35 +00007915 break;
Steve Naroff35d85152007-05-07 00:24:15 +00007916 }
7917 if (resultType.isNull())
Sebastian Redlc215cfc2009-01-19 00:08:26 +00007918 return ExprError();
Douglas Gregor084d8552009-03-13 23:49:33 +00007919
John McCall7decc9e2010-11-18 06:31:45 +00007920 return Owned(new (Context) UnaryOperator(Input, Opc, resultType,
7921 VK, OK, OpLoc));
Steve Naroff35d85152007-05-07 00:24:15 +00007922}
Chris Lattnereefa10e2007-05-28 06:56:27 +00007923
John McCalldadc5752010-08-24 06:29:42 +00007924ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
John McCalle3027922010-08-25 11:45:40 +00007925 UnaryOperatorKind Opc,
7926 Expr *Input) {
Anders Carlsson461a2c02009-11-14 21:26:41 +00007927 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType() &&
Eli Friedman8ed2bac2010-09-05 23:15:52 +00007928 UnaryOperator::getOverloadedOperator(Opc) != OO_None) {
Douglas Gregor084d8552009-03-13 23:49:33 +00007929 // Find all of the overloaded operators visible from this
7930 // point. We perform both an operator-name lookup from the local
7931 // scope and an argument-dependent lookup based on the types of
7932 // the arguments.
John McCall4c4c1df2010-01-26 03:27:55 +00007933 UnresolvedSet<16> Functions;
Douglas Gregor084d8552009-03-13 23:49:33 +00007934 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
John McCall4c4c1df2010-01-26 03:27:55 +00007935 if (S && OverOp != OO_None)
7936 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
7937 Functions);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007938
John McCallb268a282010-08-23 23:25:46 +00007939 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
Douglas Gregor084d8552009-03-13 23:49:33 +00007940 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007941
John McCallb268a282010-08-23 23:25:46 +00007942 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
Douglas Gregor084d8552009-03-13 23:49:33 +00007943}
7944
Douglas Gregor5287f092009-11-05 00:51:44 +00007945// Unary Operators. 'Tok' is the token for the operator.
John McCalldadc5752010-08-24 06:29:42 +00007946ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
John McCallb268a282010-08-23 23:25:46 +00007947 tok::TokenKind Op, Expr *Input) {
7948 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
Douglas Gregor5287f092009-11-05 00:51:44 +00007949}
7950
Steve Naroff66356bd2007-09-16 14:56:35 +00007951/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
John McCalldadc5752010-08-24 06:29:42 +00007952ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00007953 SourceLocation LabLoc,
7954 IdentifierInfo *LabelII) {
Chris Lattnereefa10e2007-05-28 06:56:27 +00007955 // Look up the record for this label identifier.
John McCallaab3e412010-08-25 08:40:02 +00007956 LabelStmt *&LabelDecl = getCurFunction()->LabelMap[LabelII];
Mike Stump4e1f26a2009-02-19 03:04:26 +00007957
Daniel Dunbar88402ce2008-08-04 16:51:22 +00007958 // If we haven't seen this label yet, create a forward reference. It
7959 // will be validated and/or cleaned up in ActOnFinishFunctionBody.
Steve Naroff846b1ec2009-03-13 15:38:40 +00007960 if (LabelDecl == 0)
Steve Narofff6009ed2009-01-21 00:14:39 +00007961 LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0);
Mike Stump4e1f26a2009-02-19 03:04:26 +00007962
Argyrios Kyrtzidis72664df2010-09-19 21:21:25 +00007963 LabelDecl->setUsed();
Chris Lattnereefa10e2007-05-28 06:56:27 +00007964 // Create the AST node. The address of a label always has type 'void*'.
Sebastian Redl6d4256c2009-03-15 17:47:39 +00007965 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
7966 Context.getPointerType(Context.VoidTy)));
Chris Lattnereefa10e2007-05-28 06:56:27 +00007967}
7968
John McCalldadc5752010-08-24 06:29:42 +00007969ExprResult
John McCallb268a282010-08-23 23:25:46 +00007970Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00007971 SourceLocation RPLoc) { // "({..})"
Chris Lattner366727f2007-07-24 16:58:17 +00007972 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
7973 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
7974
Douglas Gregor6cf3f3c2010-03-10 04:54:39 +00007975 bool isFileScope
7976 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0);
Chris Lattnera69b0762009-04-25 19:11:05 +00007977 if (isFileScope)
Sebastian Redl6d4256c2009-03-15 17:47:39 +00007978 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
Eli Friedman52cc0162009-01-24 23:09:00 +00007979
Chris Lattner366727f2007-07-24 16:58:17 +00007980 // FIXME: there are a variety of strange constraints to enforce here, for
7981 // example, it is not possible to goto into a stmt expression apparently.
7982 // More semantic analysis is needed.
Mike Stump4e1f26a2009-02-19 03:04:26 +00007983
Chris Lattner366727f2007-07-24 16:58:17 +00007984 // If there are sub stmts in the compound stmt, take the type of the last one
7985 // as the type of the stmtexpr.
7986 QualType Ty = Context.VoidTy;
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00007987 bool StmtExprMayBindToTemp = false;
Chris Lattner944d3062008-07-26 19:51:01 +00007988 if (!Compound->body_empty()) {
7989 Stmt *LastStmt = Compound->body_back();
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00007990 LabelStmt *LastLabelStmt = 0;
Chris Lattner944d3062008-07-26 19:51:01 +00007991 // If LastStmt is a label, skip down through into the body.
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00007992 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) {
7993 LastLabelStmt = Label;
Chris Lattner944d3062008-07-26 19:51:01 +00007994 LastStmt = Label->getSubStmt();
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00007995 }
7996 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt)) {
John McCall34376a62010-12-04 03:47:34 +00007997 // Do function/array conversion on the last expression, but not
7998 // lvalue-to-rvalue. However, initialize an unqualified type.
7999 DefaultFunctionArrayConversion(LastExpr);
8000 Ty = LastExpr->getType().getUnqualifiedType();
8001
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00008002 if (!Ty->isDependentType() && !LastExpr->isTypeDependent()) {
8003 ExprResult Res = PerformCopyInitialization(
8004 InitializedEntity::InitializeResult(LPLoc,
8005 Ty,
8006 false),
8007 SourceLocation(),
8008 Owned(LastExpr));
8009 if (Res.isInvalid())
8010 return ExprError();
8011 if ((LastExpr = Res.takeAs<Expr>())) {
8012 if (!LastLabelStmt)
8013 Compound->setLastStmt(LastExpr);
8014 else
8015 LastLabelStmt->setSubStmt(LastExpr);
8016 StmtExprMayBindToTemp = true;
8017 }
8018 }
8019 }
Chris Lattner944d3062008-07-26 19:51:01 +00008020 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008021
Eli Friedmanba961a92009-03-23 00:24:07 +00008022 // FIXME: Check that expression type is complete/non-abstract; statement
8023 // expressions are not lvalues.
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00008024 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
8025 if (StmtExprMayBindToTemp)
8026 return MaybeBindToTemporary(ResStmtExpr);
8027 return Owned(ResStmtExpr);
Chris Lattner366727f2007-07-24 16:58:17 +00008028}
Steve Naroff78864672007-08-01 22:05:33 +00008029
John McCalldadc5752010-08-24 06:29:42 +00008030ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
John McCall36226622010-10-12 02:09:17 +00008031 TypeSourceInfo *TInfo,
8032 OffsetOfComponent *CompPtr,
8033 unsigned NumComponents,
8034 SourceLocation RParenLoc) {
Douglas Gregor882211c2010-04-28 22:16:22 +00008035 QualType ArgTy = TInfo->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008036 bool Dependent = ArgTy->isDependentType();
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00008037 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor882211c2010-04-28 22:16:22 +00008038
Chris Lattnerf17bd422007-08-30 17:45:32 +00008039 // We must have at least one component that refers to the type, and the first
8040 // one is known to be a field designator. Verify that the ArgTy represents
8041 // a struct/union/class.
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008042 if (!Dependent && !ArgTy->isRecordType())
Douglas Gregor882211c2010-04-28 22:16:22 +00008043 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
8044 << ArgTy << TypeRange);
8045
8046 // Type must be complete per C99 7.17p3 because a declaring a variable
8047 // with an incomplete type would be ill-formed.
8048 if (!Dependent
8049 && RequireCompleteType(BuiltinLoc, ArgTy,
8050 PDiag(diag::err_offsetof_incomplete_type)
8051 << TypeRange))
8052 return ExprError();
8053
Chris Lattner78502cf2007-08-31 21:49:13 +00008054 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
8055 // GCC extension, diagnose them.
Eli Friedman988a16b2009-02-27 06:44:11 +00008056 // FIXME: This diagnostic isn't actually visible because the location is in
8057 // a system header!
Chris Lattner78502cf2007-08-31 21:49:13 +00008058 if (NumComponents != 1)
Chris Lattnerf490e152008-11-19 05:27:50 +00008059 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
8060 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
Douglas Gregor882211c2010-04-28 22:16:22 +00008061
8062 bool DidWarnAboutNonPOD = false;
8063 QualType CurrentType = ArgTy;
8064 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
8065 llvm::SmallVector<OffsetOfNode, 4> Comps;
8066 llvm::SmallVector<Expr*, 4> Exprs;
8067 for (unsigned i = 0; i != NumComponents; ++i) {
8068 const OffsetOfComponent &OC = CompPtr[i];
8069 if (OC.isBrackets) {
8070 // Offset of an array sub-field. TODO: Should we allow vector elements?
8071 if (!CurrentType->isDependentType()) {
8072 const ArrayType *AT = Context.getAsArrayType(CurrentType);
8073 if(!AT)
8074 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
8075 << CurrentType);
8076 CurrentType = AT->getElementType();
8077 } else
8078 CurrentType = Context.DependentTy;
8079
8080 // The expression must be an integral expression.
8081 // FIXME: An integral constant expression?
8082 Expr *Idx = static_cast<Expr*>(OC.U.E);
8083 if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
8084 !Idx->getType()->isIntegerType())
8085 return ExprError(Diag(Idx->getLocStart(),
8086 diag::err_typecheck_subscript_not_integer)
8087 << Idx->getSourceRange());
8088
8089 // Record this array index.
8090 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
8091 Exprs.push_back(Idx);
8092 continue;
8093 }
8094
8095 // Offset of a field.
8096 if (CurrentType->isDependentType()) {
8097 // We have the offset of a field, but we can't look into the dependent
8098 // type. Just record the identifier of the field.
8099 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
8100 CurrentType = Context.DependentTy;
8101 continue;
8102 }
8103
8104 // We need to have a complete type to look into.
8105 if (RequireCompleteType(OC.LocStart, CurrentType,
8106 diag::err_offsetof_incomplete_type))
8107 return ExprError();
8108
8109 // Look for the designated field.
8110 const RecordType *RC = CurrentType->getAs<RecordType>();
8111 if (!RC)
8112 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
8113 << CurrentType);
8114 RecordDecl *RD = RC->getDecl();
8115
8116 // C++ [lib.support.types]p5:
8117 // The macro offsetof accepts a restricted set of type arguments in this
8118 // International Standard. type shall be a POD structure or a POD union
8119 // (clause 9).
8120 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
8121 if (!CRD->isPOD() && !DidWarnAboutNonPOD &&
8122 DiagRuntimeBehavior(BuiltinLoc,
8123 PDiag(diag::warn_offsetof_non_pod_type)
8124 << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
8125 << CurrentType))
8126 DidWarnAboutNonPOD = true;
8127 }
8128
8129 // Look for the field.
8130 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName);
8131 LookupQualifiedName(R, RD);
8132 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
Francois Pichet783dd6e2010-11-21 06:08:52 +00008133 IndirectFieldDecl *IndirectMemberDecl = 0;
8134 if (!MemberDecl) {
Benjamin Kramer39593702010-11-21 14:11:41 +00008135 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
Francois Pichet783dd6e2010-11-21 06:08:52 +00008136 MemberDecl = IndirectMemberDecl->getAnonField();
8137 }
8138
Douglas Gregor882211c2010-04-28 22:16:22 +00008139 if (!MemberDecl)
8140 return ExprError(Diag(BuiltinLoc, diag::err_no_member)
8141 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
8142 OC.LocEnd));
8143
Douglas Gregor10982ea2010-04-28 22:36:06 +00008144 // C99 7.17p3:
8145 // (If the specified member is a bit-field, the behavior is undefined.)
8146 //
8147 // We diagnose this as an error.
8148 if (MemberDecl->getBitWidth()) {
8149 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
8150 << MemberDecl->getDeclName()
8151 << SourceRange(BuiltinLoc, RParenLoc);
8152 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
8153 return ExprError();
8154 }
Eli Friedman74ef7cf2010-08-05 10:11:36 +00008155
8156 RecordDecl *Parent = MemberDecl->getParent();
Francois Pichet783dd6e2010-11-21 06:08:52 +00008157 if (IndirectMemberDecl)
8158 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
Eli Friedman74ef7cf2010-08-05 10:11:36 +00008159
Douglas Gregord1702062010-04-29 00:18:15 +00008160 // If the member was found in a base class, introduce OffsetOfNodes for
8161 // the base class indirections.
8162 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
8163 /*DetectVirtual=*/false);
Eli Friedman74ef7cf2010-08-05 10:11:36 +00008164 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) {
Douglas Gregord1702062010-04-29 00:18:15 +00008165 CXXBasePath &Path = Paths.front();
8166 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end();
8167 B != BEnd; ++B)
8168 Comps.push_back(OffsetOfNode(B->Base));
8169 }
Eli Friedman74ef7cf2010-08-05 10:11:36 +00008170
Francois Pichet783dd6e2010-11-21 06:08:52 +00008171 if (IndirectMemberDecl) {
8172 for (IndirectFieldDecl::chain_iterator FI =
8173 IndirectMemberDecl->chain_begin(),
8174 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) {
8175 assert(isa<FieldDecl>(*FI));
8176 Comps.push_back(OffsetOfNode(OC.LocStart,
8177 cast<FieldDecl>(*FI), OC.LocEnd));
8178 }
8179 } else
Douglas Gregor882211c2010-04-28 22:16:22 +00008180 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
Francois Pichet783dd6e2010-11-21 06:08:52 +00008181
Douglas Gregor882211c2010-04-28 22:16:22 +00008182 CurrentType = MemberDecl->getType().getNonReferenceType();
8183 }
8184
8185 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc,
8186 TInfo, Comps.data(), Comps.size(),
8187 Exprs.data(), Exprs.size(), RParenLoc));
8188}
Mike Stump4e1f26a2009-02-19 03:04:26 +00008189
John McCalldadc5752010-08-24 06:29:42 +00008190ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
John McCall36226622010-10-12 02:09:17 +00008191 SourceLocation BuiltinLoc,
8192 SourceLocation TypeLoc,
8193 ParsedType argty,
8194 OffsetOfComponent *CompPtr,
8195 unsigned NumComponents,
8196 SourceLocation RPLoc) {
8197
Douglas Gregor882211c2010-04-28 22:16:22 +00008198 TypeSourceInfo *ArgTInfo;
8199 QualType ArgTy = GetTypeFromParser(argty, &ArgTInfo);
8200 if (ArgTy.isNull())
8201 return ExprError();
8202
Eli Friedman06dcfd92010-08-05 10:15:45 +00008203 if (!ArgTInfo)
8204 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc);
8205
8206 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents,
8207 RPLoc);
Chris Lattnerf17bd422007-08-30 17:45:32 +00008208}
8209
8210
John McCalldadc5752010-08-24 06:29:42 +00008211ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
John McCall36226622010-10-12 02:09:17 +00008212 Expr *CondExpr,
8213 Expr *LHSExpr, Expr *RHSExpr,
8214 SourceLocation RPLoc) {
Steve Naroff9efdabc2007-08-03 21:21:27 +00008215 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
8216
John McCall7decc9e2010-11-18 06:31:45 +00008217 ExprValueKind VK = VK_RValue;
8218 ExprObjectKind OK = OK_Ordinary;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008219 QualType resType;
Douglas Gregor56751b52009-09-25 04:25:58 +00008220 bool ValueDependent = false;
Douglas Gregor0df91122009-05-19 22:43:30 +00008221 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008222 resType = Context.DependentTy;
Douglas Gregor56751b52009-09-25 04:25:58 +00008223 ValueDependent = true;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008224 } else {
8225 // The conditional expression is required to be a constant expression.
8226 llvm::APSInt condEval(32);
8227 SourceLocation ExpLoc;
8228 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
Sebastian Redl6d4256c2009-03-15 17:47:39 +00008229 return ExprError(Diag(ExpLoc,
8230 diag::err_typecheck_choose_expr_requires_constant)
8231 << CondExpr->getSourceRange());
Steve Naroff9efdabc2007-08-03 21:21:27 +00008232
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008233 // If the condition is > zero, then the AST type is the same as the LSHExpr.
John McCall7decc9e2010-11-18 06:31:45 +00008234 Expr *ActiveExpr = condEval.getZExtValue() ? LHSExpr : RHSExpr;
8235
8236 resType = ActiveExpr->getType();
8237 ValueDependent = ActiveExpr->isValueDependent();
8238 VK = ActiveExpr->getValueKind();
8239 OK = ActiveExpr->getObjectKind();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008240 }
8241
Sebastian Redl6d4256c2009-03-15 17:47:39 +00008242 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
John McCall7decc9e2010-11-18 06:31:45 +00008243 resType, VK, OK, RPLoc,
Douglas Gregor56751b52009-09-25 04:25:58 +00008244 resType->isDependentType(),
8245 ValueDependent));
Steve Naroff9efdabc2007-08-03 21:21:27 +00008246}
8247
Steve Naroffc540d662008-09-03 18:15:37 +00008248//===----------------------------------------------------------------------===//
8249// Clang Extensions.
8250//===----------------------------------------------------------------------===//
8251
8252/// ActOnBlockStart - This callback is invoked when a block literal is started.
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008253void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) {
Douglas Gregor9a28e842010-03-01 23:15:13 +00008254 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc);
8255 PushBlockScope(BlockScope, Block);
8256 CurContext->addDecl(Block);
Fariborz Jahanian1babe772010-07-09 18:44:02 +00008257 if (BlockScope)
8258 PushDeclContext(BlockScope, Block);
8259 else
8260 CurContext = Block;
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008261}
8262
Mike Stump82f071f2009-02-04 22:31:32 +00008263void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
Mike Stumpf70bcf72009-05-07 18:43:07 +00008264 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
Douglas Gregor9a28e842010-03-01 23:15:13 +00008265 BlockScopeInfo *CurBlock = getCurBlock();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008266
John McCall8cb7bdf2010-06-04 23:28:52 +00008267 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope);
John McCalla3ccba02010-06-04 11:21:44 +00008268 CurBlock->TheDecl->setSignatureAsWritten(Sig);
John McCall8cb7bdf2010-06-04 23:28:52 +00008269 QualType T = Sig->getType();
Mike Stump82f071f2009-02-04 22:31:32 +00008270
John McCall8e346702010-06-04 19:02:56 +00008271 bool isVariadic;
John McCalla3ccba02010-06-04 11:21:44 +00008272 QualType RetTy;
8273 if (const FunctionType *Fn = T->getAs<FunctionType>()) {
John McCall8e346702010-06-04 19:02:56 +00008274 CurBlock->FunctionType = T;
John McCalla3ccba02010-06-04 11:21:44 +00008275 RetTy = Fn->getResultType();
John McCall8e346702010-06-04 19:02:56 +00008276 isVariadic =
John McCalla3ccba02010-06-04 11:21:44 +00008277 !isa<FunctionProtoType>(Fn) || cast<FunctionProtoType>(Fn)->isVariadic();
8278 } else {
8279 RetTy = T;
John McCall8e346702010-06-04 19:02:56 +00008280 isVariadic = false;
John McCalla3ccba02010-06-04 11:21:44 +00008281 }
Mike Stump11289f42009-09-09 15:08:12 +00008282
John McCall8e346702010-06-04 19:02:56 +00008283 CurBlock->TheDecl->setIsVariadic(isVariadic);
Douglas Gregorb92a1562010-02-03 00:27:59 +00008284
John McCalla3ccba02010-06-04 11:21:44 +00008285 // Don't allow returning an array by value.
8286 if (RetTy->isArrayType()) {
8287 Diag(ParamInfo.getSourceRange().getBegin(), diag::err_block_returns_array);
Mike Stump82f071f2009-02-04 22:31:32 +00008288 return;
8289 }
8290
John McCalla3ccba02010-06-04 11:21:44 +00008291 // Don't allow returning a objc interface by value.
8292 if (RetTy->isObjCObjectType()) {
8293 Diag(ParamInfo.getSourceRange().getBegin(),
8294 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
8295 return;
8296 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008297
John McCalla3ccba02010-06-04 11:21:44 +00008298 // Context.DependentTy is used as a placeholder for a missing block
John McCall8e346702010-06-04 19:02:56 +00008299 // return type. TODO: what should we do with declarators like:
8300 // ^ * { ... }
8301 // If the answer is "apply template argument deduction"....
John McCalla3ccba02010-06-04 11:21:44 +00008302 if (RetTy != Context.DependentTy)
8303 CurBlock->ReturnType = RetTy;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008304
John McCalla3ccba02010-06-04 11:21:44 +00008305 // Push block parameters from the declarator if we had them.
John McCall8e346702010-06-04 19:02:56 +00008306 llvm::SmallVector<ParmVarDecl*, 8> Params;
Abramo Bagnara6d810632010-12-14 22:11:44 +00008307 if (isa<FunctionProtoType>(T.IgnoreParens())) {
8308 FunctionProtoTypeLoc TL
8309 = cast<FunctionProtoTypeLoc>(Sig->getTypeLoc().IgnoreParens());
John McCalla3ccba02010-06-04 11:21:44 +00008310 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
8311 ParmVarDecl *Param = TL.getArg(I);
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +00008312 if (Param->getIdentifier() == 0 &&
8313 !Param->isImplicit() &&
8314 !Param->isInvalidDecl() &&
8315 !getLangOptions().CPlusPlus)
8316 Diag(Param->getLocation(), diag::err_parameter_name_omitted);
John McCall8e346702010-06-04 19:02:56 +00008317 Params.push_back(Param);
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +00008318 }
John McCalla3ccba02010-06-04 11:21:44 +00008319
8320 // Fake up parameter variables if we have a typedef, like
8321 // ^ fntype { ... }
8322 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
8323 for (FunctionProtoType::arg_type_iterator
8324 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) {
8325 ParmVarDecl *Param =
8326 BuildParmVarDeclForTypedef(CurBlock->TheDecl,
8327 ParamInfo.getSourceRange().getBegin(),
8328 *I);
John McCall8e346702010-06-04 19:02:56 +00008329 Params.push_back(Param);
John McCalla3ccba02010-06-04 11:21:44 +00008330 }
Steve Naroffc540d662008-09-03 18:15:37 +00008331 }
John McCalla3ccba02010-06-04 11:21:44 +00008332
John McCall8e346702010-06-04 19:02:56 +00008333 // Set the parameters on the block decl.
Douglas Gregorb524d902010-11-01 18:37:59 +00008334 if (!Params.empty()) {
John McCall8e346702010-06-04 19:02:56 +00008335 CurBlock->TheDecl->setParams(Params.data(), Params.size());
Douglas Gregorb524d902010-11-01 18:37:59 +00008336 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(),
8337 CurBlock->TheDecl->param_end(),
8338 /*CheckParameterNames=*/false);
8339 }
8340
John McCalla3ccba02010-06-04 11:21:44 +00008341 // Finally we can process decl attributes.
Douglas Gregor758a8692009-06-17 21:51:59 +00008342 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
John McCalldf8b37c2010-03-22 09:20:08 +00008343
John McCall8e346702010-06-04 19:02:56 +00008344 if (!isVariadic && CurBlock->TheDecl->getAttr<SentinelAttr>()) {
John McCalla3ccba02010-06-04 11:21:44 +00008345 Diag(ParamInfo.getAttributes()->getLoc(),
8346 diag::warn_attribute_sentinel_not_variadic) << 1;
8347 // FIXME: remove the attribute.
8348 }
8349
8350 // Put the parameter variables in scope. We can bail out immediately
8351 // if we don't have any.
John McCall8e346702010-06-04 19:02:56 +00008352 if (Params.empty())
John McCalla3ccba02010-06-04 11:21:44 +00008353 return;
8354
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008355 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
John McCallf7b2fb52010-01-22 00:28:27 +00008356 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) {
8357 (*AI)->setOwningFunction(CurBlock->TheDecl);
8358
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008359 // If this has an identifier, add it to the scope stack.
John McCalldf8b37c2010-03-22 09:20:08 +00008360 if ((*AI)->getIdentifier()) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00008361 CheckShadow(CurBlock->TheScope, *AI);
John McCalldf8b37c2010-03-22 09:20:08 +00008362
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008363 PushOnScopeChains(*AI, CurBlock->TheScope);
John McCalldf8b37c2010-03-22 09:20:08 +00008364 }
John McCallf7b2fb52010-01-22 00:28:27 +00008365 }
Steve Naroffc540d662008-09-03 18:15:37 +00008366}
8367
8368/// ActOnBlockError - If there is an error parsing a block, this callback
8369/// is invoked to pop the information about the block from the action impl.
8370void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
Steve Naroffc540d662008-09-03 18:15:37 +00008371 // Pop off CurBlock, handle nested blocks.
Chris Lattner41b86942009-04-21 22:38:46 +00008372 PopDeclContext();
Douglas Gregor9a28e842010-03-01 23:15:13 +00008373 PopFunctionOrBlockScope();
Steve Naroffc540d662008-09-03 18:15:37 +00008374}
8375
8376/// ActOnBlockStmtExpr - This is called when the body of a block statement
8377/// literal was successfully completed. ^(int x){...}
John McCalldadc5752010-08-24 06:29:42 +00008378ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
John McCallb268a282010-08-23 23:25:46 +00008379 Stmt *Body, Scope *CurScope) {
Chris Lattner9eac9312009-03-27 04:18:06 +00008380 // If blocks are disabled, emit an error.
8381 if (!LangOpts.Blocks)
8382 Diag(CaretLoc, diag::err_blocks_disable);
Mike Stump11289f42009-09-09 15:08:12 +00008383
Douglas Gregor9a28e842010-03-01 23:15:13 +00008384 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
Fariborz Jahanian1babe772010-07-09 18:44:02 +00008385
Steve Naroff1d95e5a2008-10-10 01:28:17 +00008386 PopDeclContext();
8387
Steve Naroffc540d662008-09-03 18:15:37 +00008388 QualType RetTy = Context.VoidTy;
Fariborz Jahanian3fd73102009-06-19 23:37:08 +00008389 if (!BSI->ReturnType.isNull())
8390 RetTy = BSI->ReturnType;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008391
Mike Stump3bf1ab42009-07-28 22:04:01 +00008392 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>();
Steve Naroffc540d662008-09-03 18:15:37 +00008393 QualType BlockTy;
John McCall8e346702010-06-04 19:02:56 +00008394
8395 // If the user wrote a function type in some form, try to use that.
8396 if (!BSI->FunctionType.isNull()) {
8397 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>();
8398
8399 FunctionType::ExtInfo Ext = FTy->getExtInfo();
8400 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
8401
8402 // Turn protoless block types into nullary block types.
8403 if (isa<FunctionNoProtoType>(FTy)) {
John McCalldb40c7f2010-12-14 08:05:40 +00008404 FunctionProtoType::ExtProtoInfo EPI;
8405 EPI.ExtInfo = Ext;
8406 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI);
John McCall8e346702010-06-04 19:02:56 +00008407
8408 // Otherwise, if we don't need to change anything about the function type,
8409 // preserve its sugar structure.
8410 } else if (FTy->getResultType() == RetTy &&
8411 (!NoReturn || FTy->getNoReturnAttr())) {
8412 BlockTy = BSI->FunctionType;
8413
8414 // Otherwise, make the minimal modifications to the function type.
8415 } else {
8416 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
John McCalldb40c7f2010-12-14 08:05:40 +00008417 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8418 EPI.TypeQuals = 0; // FIXME: silently?
8419 EPI.ExtInfo = Ext;
John McCall8e346702010-06-04 19:02:56 +00008420 BlockTy = Context.getFunctionType(RetTy,
8421 FPT->arg_type_begin(),
8422 FPT->getNumArgs(),
John McCalldb40c7f2010-12-14 08:05:40 +00008423 EPI);
John McCall8e346702010-06-04 19:02:56 +00008424 }
8425
8426 // If we don't have a function type, just build one from nothing.
8427 } else {
John McCalldb40c7f2010-12-14 08:05:40 +00008428 FunctionProtoType::ExtProtoInfo EPI;
8429 EPI.ExtInfo = FunctionType::ExtInfo(NoReturn, 0, CC_Default);
8430 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI);
John McCall8e346702010-06-04 19:02:56 +00008431 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008432
John McCall8e346702010-06-04 19:02:56 +00008433 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(),
8434 BSI->TheDecl->param_end());
Steve Naroffc540d662008-09-03 18:15:37 +00008435 BlockTy = Context.getBlockPointerType(BlockTy);
Mike Stump4e1f26a2009-02-19 03:04:26 +00008436
Chris Lattner45542ea2009-04-19 05:28:12 +00008437 // If needed, diagnose invalid gotos and switches in the block.
John McCallaab3e412010-08-25 08:40:02 +00008438 if (getCurFunction()->NeedsScopeChecking() && !hasAnyErrorsInThisFunction())
John McCallb268a282010-08-23 23:25:46 +00008439 DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
Mike Stump11289f42009-09-09 15:08:12 +00008440
John McCallb268a282010-08-23 23:25:46 +00008441 BSI->TheDecl->setBody(cast<CompoundStmt>(Body));
Mike Stump314825b2010-01-19 23:08:01 +00008442
8443 bool Good = true;
8444 // Check goto/label use.
8445 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
8446 I = BSI->LabelMap.begin(), E = BSI->LabelMap.end(); I != E; ++I) {
8447 LabelStmt *L = I->second;
8448
8449 // Verify that we have no forward references left. If so, there was a goto
8450 // or address of a label taken, but no definition of it.
Argyrios Kyrtzidis72664df2010-09-19 21:21:25 +00008451 if (L->getSubStmt() != 0) {
8452 if (!L->isUsed())
8453 Diag(L->getIdentLoc(), diag::warn_unused_label) << L->getName();
Mike Stump314825b2010-01-19 23:08:01 +00008454 continue;
Argyrios Kyrtzidis72664df2010-09-19 21:21:25 +00008455 }
Mike Stump314825b2010-01-19 23:08:01 +00008456
8457 // Emit error.
8458 Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
8459 Good = false;
8460 }
Douglas Gregor9a28e842010-03-01 23:15:13 +00008461 if (!Good) {
8462 PopFunctionOrBlockScope();
Mike Stump314825b2010-01-19 23:08:01 +00008463 return ExprError();
Douglas Gregor9a28e842010-03-01 23:15:13 +00008464 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008465
John McCall1d570a72010-08-25 05:56:39 +00008466 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy,
8467 BSI->hasBlockDeclRefExprs);
8468
Ted Kremenek918fe842010-03-20 21:06:02 +00008469 // Issue any analysis-based warnings.
Ted Kremenek0b405322010-03-23 00:13:23 +00008470 const sema::AnalysisBasedWarnings::Policy &WP =
8471 AnalysisWarnings.getDefaultPolicy();
John McCall1d570a72010-08-25 05:56:39 +00008472 AnalysisWarnings.IssueWarnings(WP, Result);
Ted Kremenek918fe842010-03-20 21:06:02 +00008473
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008474 PopFunctionOrBlockScope();
Douglas Gregor9a28e842010-03-01 23:15:13 +00008475 return Owned(Result);
Steve Naroffc540d662008-09-03 18:15:37 +00008476}
8477
John McCalldadc5752010-08-24 06:29:42 +00008478ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
John McCallba7bf592010-08-24 05:47:05 +00008479 Expr *expr, ParsedType type,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00008480 SourceLocation RPLoc) {
Abramo Bagnara27db2392010-08-10 10:06:15 +00008481 TypeSourceInfo *TInfo;
8482 QualType T = GetTypeFromParser(type, &TInfo);
John McCallb268a282010-08-23 23:25:46 +00008483 return BuildVAArgExpr(BuiltinLoc, expr, TInfo, RPLoc);
Abramo Bagnara27db2392010-08-10 10:06:15 +00008484}
8485
John McCalldadc5752010-08-24 06:29:42 +00008486ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
John McCall7decc9e2010-11-18 06:31:45 +00008487 Expr *E, TypeSourceInfo *TInfo,
8488 SourceLocation RPLoc) {
Chris Lattner56382aa2009-04-05 15:49:53 +00008489 Expr *OrigExpr = E;
Mike Stump11289f42009-09-09 15:08:12 +00008490
Eli Friedman121ba0c2008-08-09 23:32:40 +00008491 // Get the va_list type
8492 QualType VaListType = Context.getBuiltinVaListType();
Eli Friedmane2cad652009-05-16 12:46:54 +00008493 if (VaListType->isArrayType()) {
8494 // Deal with implicit array decay; for example, on x86-64,
8495 // va_list is an array, but it's supposed to decay to
8496 // a pointer for va_arg.
Eli Friedman121ba0c2008-08-09 23:32:40 +00008497 VaListType = Context.getArrayDecayedType(VaListType);
Eli Friedmane2cad652009-05-16 12:46:54 +00008498 // Make sure the input expression also decays appropriately.
8499 UsualUnaryConversions(E);
8500 } else {
8501 // Otherwise, the va_list argument must be an l-value because
8502 // it is modified by va_arg.
Mike Stump11289f42009-09-09 15:08:12 +00008503 if (!E->isTypeDependent() &&
Douglas Gregorad3150c2009-05-19 23:10:31 +00008504 CheckForModifiableLvalue(E, BuiltinLoc, *this))
Eli Friedmane2cad652009-05-16 12:46:54 +00008505 return ExprError();
8506 }
Eli Friedman121ba0c2008-08-09 23:32:40 +00008507
Douglas Gregorad3150c2009-05-19 23:10:31 +00008508 if (!E->isTypeDependent() &&
8509 !Context.hasSameType(VaListType, E->getType())) {
Sebastian Redl6d4256c2009-03-15 17:47:39 +00008510 return ExprError(Diag(E->getLocStart(),
8511 diag::err_first_argument_to_va_arg_not_of_type_va_list)
Chris Lattner56382aa2009-04-05 15:49:53 +00008512 << OrigExpr->getType() << E->getSourceRange());
Chris Lattner3f5cd772009-04-05 00:59:53 +00008513 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008514
Eli Friedmanba961a92009-03-23 00:24:07 +00008515 // FIXME: Check that type is complete/non-abstract
Anders Carlsson7e13ab82007-10-15 20:28:48 +00008516 // FIXME: Warn if a non-POD type is passed in.
Mike Stump4e1f26a2009-02-19 03:04:26 +00008517
Abramo Bagnara27db2392010-08-10 10:06:15 +00008518 QualType T = TInfo->getType().getNonLValueExprType(Context);
8519 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T));
Anders Carlsson7e13ab82007-10-15 20:28:48 +00008520}
8521
John McCalldadc5752010-08-24 06:29:42 +00008522ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
Douglas Gregor3be4b122008-11-29 04:51:27 +00008523 // The type of __null will be int or long, depending on the size of
8524 // pointers on the target.
8525 QualType Ty;
8526 if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth())
8527 Ty = Context.IntTy;
8528 else
8529 Ty = Context.LongTy;
8530
Sebastian Redl6d4256c2009-03-15 17:47:39 +00008531 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
Douglas Gregor3be4b122008-11-29 04:51:27 +00008532}
8533
Alexis Huntc46382e2010-04-28 23:02:27 +00008534static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType,
Douglas Gregora771f462010-03-31 17:46:05 +00008535 Expr *SrcExpr, FixItHint &Hint) {
Anders Carlssonace5d072009-11-10 04:46:30 +00008536 if (!SemaRef.getLangOptions().ObjC1)
8537 return;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008538
Anders Carlssonace5d072009-11-10 04:46:30 +00008539 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
8540 if (!PT)
8541 return;
8542
8543 // Check if the destination is of type 'id'.
8544 if (!PT->isObjCIdType()) {
8545 // Check if the destination is the 'NSString' interface.
8546 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();
8547 if (!ID || !ID->getIdentifier()->isStr("NSString"))
8548 return;
8549 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008550
Anders Carlssonace5d072009-11-10 04:46:30 +00008551 // Strip off any parens and casts.
8552 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr->IgnoreParenCasts());
8553 if (!SL || SL->isWide())
8554 return;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008555
Douglas Gregora771f462010-03-31 17:46:05 +00008556 Hint = FixItHint::CreateInsertion(SL->getLocStart(), "@");
Anders Carlssonace5d072009-11-10 04:46:30 +00008557}
8558
Chris Lattner9bad62c2008-01-04 18:04:52 +00008559bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
8560 SourceLocation Loc,
8561 QualType DstType, QualType SrcType,
Douglas Gregor4f4946a2010-04-22 00:20:18 +00008562 Expr *SrcExpr, AssignmentAction Action,
8563 bool *Complained) {
8564 if (Complained)
8565 *Complained = false;
8566
Chris Lattner9bad62c2008-01-04 18:04:52 +00008567 // Decode the result (notice that AST's are still created for extensions).
8568 bool isInvalid = false;
8569 unsigned DiagKind;
Douglas Gregora771f462010-03-31 17:46:05 +00008570 FixItHint Hint;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008571
Chris Lattner9bad62c2008-01-04 18:04:52 +00008572 switch (ConvTy) {
8573 default: assert(0 && "Unknown conversion type");
8574 case Compatible: return false;
Chris Lattner940cfeb2008-01-04 18:22:42 +00008575 case PointerToInt:
Chris Lattner9bad62c2008-01-04 18:04:52 +00008576 DiagKind = diag::ext_typecheck_convert_pointer_int;
8577 break;
Chris Lattner940cfeb2008-01-04 18:22:42 +00008578 case IntToPointer:
8579 DiagKind = diag::ext_typecheck_convert_int_pointer;
8580 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008581 case IncompatiblePointer:
Douglas Gregora771f462010-03-31 17:46:05 +00008582 MakeObjCStringLiteralFixItHint(*this, DstType, SrcExpr, Hint);
Chris Lattner9bad62c2008-01-04 18:04:52 +00008583 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
8584 break;
Eli Friedman80160bd2009-03-22 23:59:44 +00008585 case IncompatiblePointerSign:
8586 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
8587 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008588 case FunctionVoidPointer:
8589 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
8590 break;
8591 case CompatiblePointerDiscardsQualifiers:
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00008592 // If the qualifiers lost were because we were applying the
8593 // (deprecated) C++ conversion from a string literal to a char*
8594 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
8595 // Ideally, this check would be performed in
8596 // CheckPointerTypesForAssignment. However, that would require a
8597 // bit of refactoring (so that the second argument is an
8598 // expression, rather than a type), which should be done as part
8599 // of a larger effort to fix CheckPointerTypesForAssignment for
8600 // C++ semantics.
8601 if (getLangOptions().CPlusPlus &&
8602 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
8603 return false;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008604 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
8605 break;
Alexis Hunt6f3de502009-11-08 07:46:34 +00008606 case IncompatibleNestedPointerQualifiers:
Fariborz Jahanianb98dade2009-11-09 22:16:37 +00008607 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00008608 break;
Steve Naroff081c7422008-09-04 15:10:53 +00008609 case IntToBlockPointer:
8610 DiagKind = diag::err_int_to_block_pointer;
8611 break;
8612 case IncompatibleBlockPointer:
Mike Stumpd79b5a82009-04-21 22:51:42 +00008613 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
Steve Naroff081c7422008-09-04 15:10:53 +00008614 break;
Steve Naroff8afa9892008-10-14 22:18:38 +00008615 case IncompatibleObjCQualifiedId:
Mike Stump4e1f26a2009-02-19 03:04:26 +00008616 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
Steve Naroff8afa9892008-10-14 22:18:38 +00008617 // it can give a more specific diagnostic.
8618 DiagKind = diag::warn_incompatible_qualified_id;
8619 break;
Anders Carlssondb5a9b62009-01-30 23:17:46 +00008620 case IncompatibleVectors:
8621 DiagKind = diag::warn_incompatible_vectors;
8622 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008623 case Incompatible:
8624 DiagKind = diag::err_typecheck_convert_incompatible;
8625 isInvalid = true;
8626 break;
8627 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008628
Douglas Gregorc68e1402010-04-09 00:35:39 +00008629 QualType FirstType, SecondType;
8630 switch (Action) {
8631 case AA_Assigning:
8632 case AA_Initializing:
8633 // The destination type comes first.
8634 FirstType = DstType;
8635 SecondType = SrcType;
8636 break;
Alexis Huntc46382e2010-04-28 23:02:27 +00008637
Douglas Gregorc68e1402010-04-09 00:35:39 +00008638 case AA_Returning:
8639 case AA_Passing:
8640 case AA_Converting:
8641 case AA_Sending:
8642 case AA_Casting:
8643 // The source type comes first.
8644 FirstType = SrcType;
8645 SecondType = DstType;
8646 break;
8647 }
Alexis Huntc46382e2010-04-28 23:02:27 +00008648
Douglas Gregorc68e1402010-04-09 00:35:39 +00008649 Diag(Loc, DiagKind) << FirstType << SecondType << Action
Anders Carlssonace5d072009-11-10 04:46:30 +00008650 << SrcExpr->getSourceRange() << Hint;
Douglas Gregor4f4946a2010-04-22 00:20:18 +00008651 if (Complained)
8652 *Complained = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008653 return isInvalid;
8654}
Anders Carlssone54e8a12008-11-30 19:50:32 +00008655
Chris Lattnerc71d08b2009-04-25 21:59:05 +00008656bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){
Eli Friedmanbb967cc2009-04-25 22:26:58 +00008657 llvm::APSInt ICEResult;
8658 if (E->isIntegerConstantExpr(ICEResult, Context)) {
8659 if (Result)
8660 *Result = ICEResult;
8661 return false;
8662 }
8663
Anders Carlssone54e8a12008-11-30 19:50:32 +00008664 Expr::EvalResult EvalResult;
8665
Mike Stump4e1f26a2009-02-19 03:04:26 +00008666 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() ||
Anders Carlssone54e8a12008-11-30 19:50:32 +00008667 EvalResult.HasSideEffects) {
8668 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange();
8669
8670 if (EvalResult.Diag) {
8671 // We only show the note if it's not the usual "invalid subexpression"
8672 // or if it's actually in a subexpression.
8673 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice ||
8674 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens())
8675 Diag(EvalResult.DiagLoc, EvalResult.Diag);
8676 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008677
Anders Carlssone54e8a12008-11-30 19:50:32 +00008678 return true;
8679 }
8680
Eli Friedmanbb967cc2009-04-25 22:26:58 +00008681 Diag(E->getExprLoc(), diag::ext_expr_not_ice) <<
8682 E->getSourceRange();
Anders Carlssone54e8a12008-11-30 19:50:32 +00008683
Eli Friedmanbb967cc2009-04-25 22:26:58 +00008684 if (EvalResult.Diag &&
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +00008685 Diags.getDiagnosticLevel(diag::ext_expr_not_ice, EvalResult.DiagLoc)
8686 != Diagnostic::Ignored)
Eli Friedmanbb967cc2009-04-25 22:26:58 +00008687 Diag(EvalResult.DiagLoc, EvalResult.Diag);
Mike Stump4e1f26a2009-02-19 03:04:26 +00008688
Anders Carlssone54e8a12008-11-30 19:50:32 +00008689 if (Result)
8690 *Result = EvalResult.Val.getInt();
8691 return false;
8692}
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008693
Douglas Gregorff790f12009-11-26 00:44:06 +00008694void
Mike Stump11289f42009-09-09 15:08:12 +00008695Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) {
Douglas Gregorff790f12009-11-26 00:44:06 +00008696 ExprEvalContexts.push_back(
8697 ExpressionEvaluationContextRecord(NewContext, ExprTemporaries.size()));
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008698}
8699
Mike Stump11289f42009-09-09 15:08:12 +00008700void
Douglas Gregorff790f12009-11-26 00:44:06 +00008701Sema::PopExpressionEvaluationContext() {
8702 // Pop the current expression evaluation context off the stack.
8703 ExpressionEvaluationContextRecord Rec = ExprEvalContexts.back();
8704 ExprEvalContexts.pop_back();
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008705
Douglas Gregorfab31f42009-12-12 07:57:52 +00008706 if (Rec.Context == PotentiallyPotentiallyEvaluated) {
8707 if (Rec.PotentiallyReferenced) {
8708 // Mark any remaining declarations in the current position of the stack
8709 // as "referenced". If they were not meant to be referenced, semantic
8710 // analysis would have eliminated them (e.g., in ActOnCXXTypeId).
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008711 for (PotentiallyReferencedDecls::iterator
Douglas Gregorfab31f42009-12-12 07:57:52 +00008712 I = Rec.PotentiallyReferenced->begin(),
8713 IEnd = Rec.PotentiallyReferenced->end();
8714 I != IEnd; ++I)
8715 MarkDeclarationReferenced(I->first, I->second);
8716 }
8717
8718 if (Rec.PotentiallyDiagnosed) {
8719 // Emit any pending diagnostics.
8720 for (PotentiallyEmittedDiagnostics::iterator
8721 I = Rec.PotentiallyDiagnosed->begin(),
8722 IEnd = Rec.PotentiallyDiagnosed->end();
8723 I != IEnd; ++I)
8724 Diag(I->first, I->second);
8725 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008726 }
Douglas Gregorff790f12009-11-26 00:44:06 +00008727
8728 // When are coming out of an unevaluated context, clear out any
8729 // temporaries that we may have created as part of the evaluation of
8730 // the expression in that context: they aren't relevant because they
8731 // will never be constructed.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008732 if (Rec.Context == Unevaluated &&
Douglas Gregorff790f12009-11-26 00:44:06 +00008733 ExprTemporaries.size() > Rec.NumTemporaries)
8734 ExprTemporaries.erase(ExprTemporaries.begin() + Rec.NumTemporaries,
8735 ExprTemporaries.end());
8736
8737 // Destroy the popped expression evaluation record.
8738 Rec.Destroy();
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008739}
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008740
8741/// \brief Note that the given declaration was referenced in the source code.
8742///
8743/// This routine should be invoke whenever a given declaration is referenced
8744/// in the source code, and where that reference occurred. If this declaration
8745/// reference means that the the declaration is used (C++ [basic.def.odr]p2,
8746/// C99 6.9p3), then the declaration will be marked as used.
8747///
8748/// \param Loc the location where the declaration was referenced.
8749///
8750/// \param D the declaration that has been referenced by the source code.
8751void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) {
8752 assert(D && "No declaration?");
Mike Stump11289f42009-09-09 15:08:12 +00008753
Douglas Gregorebada0772010-06-17 23:14:26 +00008754 if (D->isUsed(false))
Douglas Gregor77b50e12009-06-22 23:06:13 +00008755 return;
Mike Stump11289f42009-09-09 15:08:12 +00008756
Douglas Gregor3beaf9b2009-10-08 21:35:42 +00008757 // Mark a parameter or variable declaration "used", regardless of whether we're in a
8758 // template or not. The reason for this is that unevaluated expressions
8759 // (e.g. (void)sizeof()) constitute a use for warning purposes (-Wunused-variables and
8760 // -Wunused-parameters)
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008761 if (isa<ParmVarDecl>(D) ||
Douglas Gregorfd27fed2010-04-07 20:29:57 +00008762 (isa<VarDecl>(D) && D->getDeclContext()->isFunctionOrMethod())) {
Anders Carlsson73067a02010-10-22 23:37:08 +00008763 D->setUsed();
Douglas Gregorfd27fed2010-04-07 20:29:57 +00008764 return;
8765 }
Alexis Huntc46382e2010-04-28 23:02:27 +00008766
Douglas Gregorfd27fed2010-04-07 20:29:57 +00008767 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D))
8768 return;
Alexis Huntc46382e2010-04-28 23:02:27 +00008769
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008770 // Do not mark anything as "used" within a dependent context; wait for
8771 // an instantiation.
8772 if (CurContext->isDependentContext())
8773 return;
Mike Stump11289f42009-09-09 15:08:12 +00008774
Douglas Gregorff790f12009-11-26 00:44:06 +00008775 switch (ExprEvalContexts.back().Context) {
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008776 case Unevaluated:
8777 // We are in an expression that is not potentially evaluated; do nothing.
8778 return;
Mike Stump11289f42009-09-09 15:08:12 +00008779
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008780 case PotentiallyEvaluated:
8781 // We are in a potentially-evaluated expression, so this declaration is
8782 // "used"; handle this below.
8783 break;
Mike Stump11289f42009-09-09 15:08:12 +00008784
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008785 case PotentiallyPotentiallyEvaluated:
8786 // We are in an expression that may be potentially evaluated; queue this
8787 // declaration reference until we know whether the expression is
8788 // potentially evaluated.
Douglas Gregorff790f12009-11-26 00:44:06 +00008789 ExprEvalContexts.back().addReferencedDecl(Loc, D);
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008790 return;
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008791
8792 case PotentiallyEvaluatedIfUsed:
8793 // Referenced declarations will only be used if the construct in the
8794 // containing expression is used.
8795 return;
Douglas Gregor0b6a6242009-06-22 20:57:11 +00008796 }
Mike Stump11289f42009-09-09 15:08:12 +00008797
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008798 // Note that this declaration has been used.
Fariborz Jahanian3a363432009-06-22 17:30:33 +00008799 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
Fariborz Jahanian477d2422009-06-22 23:34:40 +00008800 unsigned TypeQuals;
Fariborz Jahanian18eb69a2009-06-22 20:37:23 +00008801 if (Constructor->isImplicit() && Constructor->isDefaultConstructor()) {
Chandler Carruthc9262402010-08-23 07:55:51 +00008802 if (Constructor->getParent()->hasTrivialConstructor())
8803 return;
8804 if (!Constructor->isUsed(false))
8805 DefineImplicitDefaultConstructor(Loc, Constructor);
Mike Stump11289f42009-09-09 15:08:12 +00008806 } else if (Constructor->isImplicit() &&
Douglas Gregor507eb872009-12-22 00:34:07 +00008807 Constructor->isCopyConstructor(TypeQuals)) {
Douglas Gregorebada0772010-06-17 23:14:26 +00008808 if (!Constructor->isUsed(false))
Fariborz Jahanian477d2422009-06-22 23:34:40 +00008809 DefineImplicitCopyConstructor(Loc, Constructor, TypeQuals);
8810 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008811
Douglas Gregor88d292c2010-05-13 16:44:06 +00008812 MarkVTableUsed(Loc, Constructor->getParent());
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00008813 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
Douglas Gregorebada0772010-06-17 23:14:26 +00008814 if (Destructor->isImplicit() && !Destructor->isUsed(false))
Fariborz Jahanian24a175b2009-06-26 23:49:16 +00008815 DefineImplicitDestructor(Loc, Destructor);
Douglas Gregor88d292c2010-05-13 16:44:06 +00008816 if (Destructor->isVirtual())
8817 MarkVTableUsed(Loc, Destructor->getParent());
Fariborz Jahanian41f79272009-06-25 21:45:19 +00008818 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) {
8819 if (MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
8820 MethodDecl->getOverloadedOperator() == OO_Equal) {
Douglas Gregorebada0772010-06-17 23:14:26 +00008821 if (!MethodDecl->isUsed(false))
Douglas Gregora57478e2010-05-01 15:04:51 +00008822 DefineImplicitCopyAssignment(Loc, MethodDecl);
Douglas Gregor88d292c2010-05-13 16:44:06 +00008823 } else if (MethodDecl->isVirtual())
8824 MarkVTableUsed(Loc, MethodDecl->getParent());
Fariborz Jahanian41f79272009-06-25 21:45:19 +00008825 }
Fariborz Jahanian49796cc72009-06-24 22:09:44 +00008826 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
Mike Stump11289f42009-09-09 15:08:12 +00008827 // Implicit instantiation of function templates and member functions of
Douglas Gregor4adbc6d2009-06-26 00:10:03 +00008828 // class templates.
Douglas Gregor69f6a362010-05-17 17:34:56 +00008829 if (Function->isImplicitlyInstantiable()) {
Douglas Gregor06db9f52009-10-12 20:18:28 +00008830 bool AlreadyInstantiated = false;
8831 if (FunctionTemplateSpecializationInfo *SpecInfo
8832 = Function->getTemplateSpecializationInfo()) {
8833 if (SpecInfo->getPointOfInstantiation().isInvalid())
8834 SpecInfo->setPointOfInstantiation(Loc);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008835 else if (SpecInfo->getTemplateSpecializationKind()
Douglas Gregorafca3b42009-10-27 20:53:28 +00008836 == TSK_ImplicitInstantiation)
Douglas Gregor06db9f52009-10-12 20:18:28 +00008837 AlreadyInstantiated = true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008838 } else if (MemberSpecializationInfo *MSInfo
Douglas Gregor06db9f52009-10-12 20:18:28 +00008839 = Function->getMemberSpecializationInfo()) {
8840 if (MSInfo->getPointOfInstantiation().isInvalid())
8841 MSInfo->setPointOfInstantiation(Loc);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008842 else if (MSInfo->getTemplateSpecializationKind()
Douglas Gregorafca3b42009-10-27 20:53:28 +00008843 == TSK_ImplicitInstantiation)
Douglas Gregor06db9f52009-10-12 20:18:28 +00008844 AlreadyInstantiated = true;
8845 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008846
Douglas Gregor7f792cf2010-01-16 22:29:39 +00008847 if (!AlreadyInstantiated) {
8848 if (isa<CXXRecordDecl>(Function->getDeclContext()) &&
8849 cast<CXXRecordDecl>(Function->getDeclContext())->isLocalClass())
8850 PendingLocalImplicitInstantiations.push_back(std::make_pair(Function,
8851 Loc));
8852 else
Chandler Carruth54080172010-08-25 08:44:16 +00008853 PendingInstantiations.push_back(std::make_pair(Function, Loc));
Douglas Gregor7f792cf2010-01-16 22:29:39 +00008854 }
Gabor Greifb6aba3e2010-08-28 00:16:06 +00008855 } else // Walk redefinitions, as some of them may be instantiable.
8856 for (FunctionDecl::redecl_iterator i(Function->redecls_begin()),
8857 e(Function->redecls_end()); i != e; ++i) {
Gabor Greif34ecff22010-08-28 01:58:12 +00008858 if (!i->isUsed(false) && i->isImplicitlyInstantiable())
Gabor Greifb6aba3e2010-08-28 00:16:06 +00008859 MarkDeclarationReferenced(Loc, *i);
8860 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008861
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008862 // FIXME: keep track of references to static functions
Argyrios Kyrtzidisdfffabd2010-08-25 10:34:54 +00008863
8864 // Recursive functions should be marked when used from another function.
8865 if (CurContext != Function)
8866 Function->setUsed(true);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008867
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008868 return;
Douglas Gregor77b50e12009-06-22 23:06:13 +00008869 }
Mike Stump11289f42009-09-09 15:08:12 +00008870
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008871 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
Douglas Gregora6ef8f02009-07-24 20:34:43 +00008872 // Implicit instantiation of static data members of class templates.
Mike Stump11289f42009-09-09 15:08:12 +00008873 if (Var->isStaticDataMember() &&
Douglas Gregor06db9f52009-10-12 20:18:28 +00008874 Var->getInstantiatedFromStaticDataMember()) {
8875 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
8876 assert(MSInfo && "Missing member specialization information?");
8877 if (MSInfo->getPointOfInstantiation().isInvalid() &&
8878 MSInfo->getTemplateSpecializationKind()== TSK_ImplicitInstantiation) {
8879 MSInfo->setPointOfInstantiation(Loc);
Chandler Carruth54080172010-08-25 08:44:16 +00008880 PendingInstantiations.push_back(std::make_pair(Var, Loc));
Douglas Gregor06db9f52009-10-12 20:18:28 +00008881 }
8882 }
Mike Stump11289f42009-09-09 15:08:12 +00008883
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008884 // FIXME: keep track of references to static data?
Douglas Gregora6ef8f02009-07-24 20:34:43 +00008885
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008886 D->setUsed(true);
Douglas Gregora6ef8f02009-07-24 20:34:43 +00008887 return;
Sam Weinigbae69142009-09-11 03:29:30 +00008888 }
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00008889}
Anders Carlsson7f84ed92009-10-09 23:51:55 +00008890
Douglas Gregor5597ab42010-05-07 23:12:07 +00008891namespace {
Chandler Carruthaf80f662010-06-09 08:17:30 +00008892 // Mark all of the declarations referenced
Douglas Gregor5597ab42010-05-07 23:12:07 +00008893 // FIXME: Not fully implemented yet! We need to have a better understanding
Chandler Carruthaf80f662010-06-09 08:17:30 +00008894 // of when we're entering
Douglas Gregor5597ab42010-05-07 23:12:07 +00008895 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> {
8896 Sema &S;
8897 SourceLocation Loc;
Chandler Carruthaf80f662010-06-09 08:17:30 +00008898
Douglas Gregor5597ab42010-05-07 23:12:07 +00008899 public:
8900 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited;
Chandler Carruthaf80f662010-06-09 08:17:30 +00008901
Douglas Gregor5597ab42010-05-07 23:12:07 +00008902 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { }
Chandler Carruthaf80f662010-06-09 08:17:30 +00008903
8904 bool TraverseTemplateArgument(const TemplateArgument &Arg);
8905 bool TraverseRecordType(RecordType *T);
Douglas Gregor5597ab42010-05-07 23:12:07 +00008906 };
8907}
8908
Chandler Carruthaf80f662010-06-09 08:17:30 +00008909bool MarkReferencedDecls::TraverseTemplateArgument(
8910 const TemplateArgument &Arg) {
Douglas Gregor5597ab42010-05-07 23:12:07 +00008911 if (Arg.getKind() == TemplateArgument::Declaration) {
8912 S.MarkDeclarationReferenced(Loc, Arg.getAsDecl());
8913 }
Chandler Carruthaf80f662010-06-09 08:17:30 +00008914
8915 return Inherited::TraverseTemplateArgument(Arg);
Douglas Gregor5597ab42010-05-07 23:12:07 +00008916}
8917
Chandler Carruthaf80f662010-06-09 08:17:30 +00008918bool MarkReferencedDecls::TraverseRecordType(RecordType *T) {
Douglas Gregor5597ab42010-05-07 23:12:07 +00008919 if (ClassTemplateSpecializationDecl *Spec
8920 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) {
8921 const TemplateArgumentList &Args = Spec->getTemplateArgs();
Douglas Gregor1ccc8412010-11-07 23:05:16 +00008922 return TraverseTemplateArguments(Args.data(), Args.size());
Douglas Gregor5597ab42010-05-07 23:12:07 +00008923 }
8924
Chandler Carruthc65667c2010-06-10 10:31:57 +00008925 return true;
Douglas Gregor5597ab42010-05-07 23:12:07 +00008926}
8927
8928void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) {
8929 MarkReferencedDecls Marker(*this, Loc);
Chandler Carruthaf80f662010-06-09 08:17:30 +00008930 Marker.TraverseType(Context.getCanonicalType(T));
Douglas Gregor5597ab42010-05-07 23:12:07 +00008931}
8932
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008933namespace {
8934 /// \brief Helper class that marks all of the declarations referenced by
8935 /// potentially-evaluated subexpressions as "referenced".
8936 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> {
8937 Sema &S;
8938
8939 public:
8940 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited;
8941
8942 explicit EvaluatedExprMarker(Sema &S) : Inherited(S.Context), S(S) { }
8943
8944 void VisitDeclRefExpr(DeclRefExpr *E) {
8945 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl());
8946 }
8947
8948 void VisitMemberExpr(MemberExpr *E) {
8949 S.MarkDeclarationReferenced(E->getMemberLoc(), E->getMemberDecl());
Douglas Gregor32b3de52010-09-11 23:32:50 +00008950 Inherited::VisitMemberExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008951 }
8952
8953 void VisitCXXNewExpr(CXXNewExpr *E) {
8954 if (E->getConstructor())
8955 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor());
8956 if (E->getOperatorNew())
8957 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorNew());
8958 if (E->getOperatorDelete())
8959 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete());
Douglas Gregor32b3de52010-09-11 23:32:50 +00008960 Inherited::VisitCXXNewExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008961 }
8962
8963 void VisitCXXDeleteExpr(CXXDeleteExpr *E) {
8964 if (E->getOperatorDelete())
8965 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete());
Douglas Gregor6ed2fee2010-09-14 22:55:20 +00008966 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType());
8967 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
8968 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
8969 S.MarkDeclarationReferenced(E->getLocStart(),
8970 S.LookupDestructor(Record));
8971 }
8972
Douglas Gregor32b3de52010-09-11 23:32:50 +00008973 Inherited::VisitCXXDeleteExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008974 }
8975
8976 void VisitCXXConstructExpr(CXXConstructExpr *E) {
8977 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor());
Douglas Gregor32b3de52010-09-11 23:32:50 +00008978 Inherited::VisitCXXConstructExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008979 }
8980
8981 void VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
8982 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl());
8983 }
Douglas Gregorf0873f42010-10-19 17:17:35 +00008984
8985 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
8986 Visit(E->getExpr());
8987 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00008988 };
8989}
8990
8991/// \brief Mark any declarations that appear within this expression or any
8992/// potentially-evaluated subexpressions as "referenced".
8993void Sema::MarkDeclarationsReferencedInExpr(Expr *E) {
8994 EvaluatedExprMarker(*this).Visit(E);
8995}
8996
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00008997/// \brief Emit a diagnostic that describes an effect on the run-time behavior
8998/// of the program being compiled.
8999///
9000/// This routine emits the given diagnostic when the code currently being
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009001/// type-checked is "potentially evaluated", meaning that there is a
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009002/// possibility that the code will actually be executable. Code in sizeof()
9003/// expressions, code used only during overload resolution, etc., are not
9004/// potentially evaluated. This routine will suppress such diagnostics or,
9005/// in the absolutely nutty case of potentially potentially evaluated
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009006/// expressions (C++ typeid), queue the diagnostic to potentially emit it
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009007/// later.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009008///
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009009/// This routine should be used for all diagnostics that describe the run-time
9010/// behavior of a program, such as passing a non-POD value through an ellipsis.
9011/// Failure to do so will likely result in spurious diagnostics or failures
9012/// during overload resolution or within sizeof/alignof/typeof/typeid.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009013bool Sema::DiagRuntimeBehavior(SourceLocation Loc,
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009014 const PartialDiagnostic &PD) {
9015 switch (ExprEvalContexts.back().Context ) {
9016 case Unevaluated:
9017 // The argument will never be evaluated, so don't complain.
9018 break;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009019
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009020 case PotentiallyEvaluated:
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00009021 case PotentiallyEvaluatedIfUsed:
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009022 Diag(Loc, PD);
9023 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009024
Douglas Gregorda8cdbc2009-12-22 01:01:55 +00009025 case PotentiallyPotentiallyEvaluated:
9026 ExprEvalContexts.back().addDiagnostic(Loc, PD);
9027 break;
9028 }
9029
9030 return false;
9031}
9032
Anders Carlsson7f84ed92009-10-09 23:51:55 +00009033bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
9034 CallExpr *CE, FunctionDecl *FD) {
9035 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
9036 return false;
9037
9038 PartialDiagnostic Note =
9039 FD ? PDiag(diag::note_function_with_incomplete_return_type_declared_here)
9040 << FD->getDeclName() : PDiag();
9041 SourceLocation NoteLoc = FD ? FD->getLocation() : SourceLocation();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009042
Anders Carlsson7f84ed92009-10-09 23:51:55 +00009043 if (RequireCompleteType(Loc, ReturnType,
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009044 FD ?
Anders Carlsson7f84ed92009-10-09 23:51:55 +00009045 PDiag(diag::err_call_function_incomplete_return)
9046 << CE->getSourceRange() << FD->getDeclName() :
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009047 PDiag(diag::err_call_incomplete_return)
Anders Carlsson7f84ed92009-10-09 23:51:55 +00009048 << CE->getSourceRange(),
9049 std::make_pair(NoteLoc, Note)))
9050 return true;
9051
9052 return false;
9053}
9054
John McCalld5707ab2009-10-12 21:59:07 +00009055// Diagnose the common s/=/==/ typo. Note that adding parentheses
9056// will prevent this condition from triggering, which is what we want.
9057void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
9058 SourceLocation Loc;
9059
John McCall0506e4a2009-11-11 02:41:58 +00009060 unsigned diagnostic = diag::warn_condition_is_assignment;
9061
John McCalld5707ab2009-10-12 21:59:07 +00009062 if (isa<BinaryOperator>(E)) {
9063 BinaryOperator *Op = cast<BinaryOperator>(E);
John McCalle3027922010-08-25 11:45:40 +00009064 if (Op->getOpcode() != BO_Assign)
John McCalld5707ab2009-10-12 21:59:07 +00009065 return;
9066
John McCallb0e419e2009-11-12 00:06:05 +00009067 // Greylist some idioms by putting them into a warning subcategory.
9068 if (ObjCMessageExpr *ME
9069 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
9070 Selector Sel = ME->getSelector();
9071
John McCallb0e419e2009-11-12 00:06:05 +00009072 // self = [<foo> init...]
9073 if (isSelfExpr(Op->getLHS())
9074 && Sel.getIdentifierInfoForSlot(0)->getName().startswith("init"))
9075 diagnostic = diag::warn_condition_is_idiomatic_assignment;
9076
9077 // <foo> = [<bar> nextObject]
9078 else if (Sel.isUnarySelector() &&
9079 Sel.getIdentifierInfoForSlot(0)->getName() == "nextObject")
9080 diagnostic = diag::warn_condition_is_idiomatic_assignment;
9081 }
John McCall0506e4a2009-11-11 02:41:58 +00009082
John McCalld5707ab2009-10-12 21:59:07 +00009083 Loc = Op->getOperatorLoc();
9084 } else if (isa<CXXOperatorCallExpr>(E)) {
9085 CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(E);
9086 if (Op->getOperator() != OO_Equal)
9087 return;
9088
9089 Loc = Op->getOperatorLoc();
9090 } else {
9091 // Not an assignment.
9092 return;
9093 }
9094
John McCalld5707ab2009-10-12 21:59:07 +00009095 SourceLocation Open = E->getSourceRange().getBegin();
John McCalle724ae92009-10-12 22:25:59 +00009096 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009097
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00009098 Diag(Loc, diagnostic) << E->getSourceRange();
Douglas Gregorfa1e36d2010-01-08 00:20:23 +00009099 Diag(Loc, diag::note_condition_assign_to_comparison)
Douglas Gregora771f462010-03-31 17:46:05 +00009100 << FixItHint::CreateReplacement(Loc, "==");
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +00009101 Diag(Loc, diag::note_condition_assign_silence)
9102 << FixItHint::CreateInsertion(Open, "(")
9103 << FixItHint::CreateInsertion(Close, ")");
John McCalld5707ab2009-10-12 21:59:07 +00009104}
9105
9106bool Sema::CheckBooleanCondition(Expr *&E, SourceLocation Loc) {
9107 DiagnoseAssignmentAsCondition(E);
9108
9109 if (!E->isTypeDependent()) {
Argyrios Kyrtzidisca766292010-11-01 18:49:26 +00009110 if (E->isBoundMemberFunction(Context))
9111 return Diag(E->getLocStart(), diag::err_invalid_use_of_bound_member_func)
9112 << E->getSourceRange();
9113
John McCall34376a62010-12-04 03:47:34 +00009114 if (getLangOptions().CPlusPlus)
9115 return CheckCXXBooleanCondition(E); // C++ 6.4p4
9116
9117 DefaultFunctionArrayLvalueConversion(E);
John McCall29cb2fd2010-12-04 06:09:13 +00009118
9119 QualType T = E->getType();
John McCall34376a62010-12-04 03:47:34 +00009120 if (!T->isScalarType()) // C99 6.8.4.1p1
9121 return Diag(Loc, diag::err_typecheck_statement_requires_scalar)
9122 << T << E->getSourceRange();
John McCalld5707ab2009-10-12 21:59:07 +00009123 }
9124
9125 return false;
9126}
Douglas Gregore60e41a2010-05-06 17:25:47 +00009127
John McCalldadc5752010-08-24 06:29:42 +00009128ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc,
9129 Expr *Sub) {
Douglas Gregor12cc7ee2010-05-06 21:39:56 +00009130 if (!Sub)
Douglas Gregore60e41a2010-05-06 17:25:47 +00009131 return ExprError();
9132
Douglas Gregorb412e172010-07-25 18:17:45 +00009133 if (CheckBooleanCondition(Sub, Loc))
Douglas Gregore60e41a2010-05-06 17:25:47 +00009134 return ExprError();
Douglas Gregore60e41a2010-05-06 17:25:47 +00009135
9136 return Owned(Sub);
9137}
John McCall36e7fe32010-10-12 00:20:44 +00009138
9139/// Check for operands with placeholder types and complain if found.
9140/// Returns true if there was an error and no recovery was possible.
9141ExprResult Sema::CheckPlaceholderExpr(Expr *E, SourceLocation Loc) {
9142 const BuiltinType *BT = E->getType()->getAs<BuiltinType>();
9143 if (!BT || !BT->isPlaceholderType()) return Owned(E);
9144
9145 // If this is overload, check for a single overload.
9146 if (BT->getKind() == BuiltinType::Overload) {
9147 if (FunctionDecl *Specialization
9148 = ResolveSingleFunctionTemplateSpecialization(E)) {
9149 // The access doesn't really matter in this case.
9150 DeclAccessPair Found = DeclAccessPair::make(Specialization,
9151 Specialization->getAccess());
9152 E = FixOverloadedFunctionReference(E, Found, Specialization);
9153 if (!E) return ExprError();
9154 return Owned(E);
9155 }
9156
John McCall36226622010-10-12 02:09:17 +00009157 Diag(Loc, diag::err_ovl_unresolvable) << E->getSourceRange();
John McCall36e7fe32010-10-12 00:20:44 +00009158 return ExprError();
9159 }
9160
9161 // Otherwise it's a use of undeduced auto.
9162 assert(BT->getKind() == BuiltinType::UndeducedAuto);
9163
9164 DeclRefExpr *DRE = cast<DeclRefExpr>(E->IgnoreParens());
9165 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
9166 << DRE->getDecl() << E->getSourceRange();
9167 return ExprError();
9168}