blob: 5c3f5e7bd104aa2fb3bd83c8e5af6972547e6d4b [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000016#include "clang/AST/DeclObjC.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000017#include "clang/AST/DeclTemplate.h"
Chris Lattner04421082008-04-08 04:40:51 +000018#include "clang/AST/ExprCXX.h"
Steve Narofff494b572008-05-29 21:12:08 +000019#include "clang/AST/ExprObjC.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000020#include "clang/Basic/PartialDiagnostic.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "clang/Basic/TargetInfo.h"
Anders Carlssond497ba72009-08-26 22:59:12 +000023#include "clang/Lex/LiteralSupport.h"
24#include "clang/Lex/Preprocessor.h"
Steve Naroff4eb206b2008-09-03 18:15:37 +000025#include "clang/Parse/DeclSpec.h"
Chris Lattner418f6c72008-10-26 23:43:26 +000026#include "clang/Parse/Designator.h"
Steve Naroff4eb206b2008-09-03 18:15:37 +000027#include "clang/Parse/Scope.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000028using namespace clang;
29
David Chisnall0f436562009-08-17 16:35:33 +000030
Douglas Gregor48f3bb92009-02-18 21:56:37 +000031/// \brief Determine whether the use of this declaration is valid, and
32/// emit any corresponding diagnostics.
33///
34/// This routine diagnoses various problems with referencing
35/// declarations that can occur when using a declaration. For example,
36/// it might warn if a deprecated or unavailable declaration is being
37/// used, or produce an error (and return true) if a C++0x deleted
38/// function is being used.
39///
Chris Lattner52338262009-10-25 22:31:57 +000040/// If IgnoreDeprecated is set to true, this should not want about deprecated
41/// decls.
42///
Douglas Gregor48f3bb92009-02-18 21:56:37 +000043/// \returns true if there was an error (this declaration cannot be
44/// referenced), false otherwise.
Chris Lattner52338262009-10-25 22:31:57 +000045///
46bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
47 bool IgnoreDeprecated) {
Chris Lattner76a642f2009-02-15 22:43:40 +000048 // See if the decl is deprecated.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +000049 if (D->getAttr<DeprecatedAttr>()) {
Douglas Gregor48f3bb92009-02-18 21:56:37 +000050 // Implementing deprecated stuff requires referencing deprecated
Chris Lattner52338262009-10-25 22:31:57 +000051 // stuff. Don't warn if we are implementing a deprecated construct.
52 bool isSilenced = IgnoreDeprecated;
Mike Stump1eb44332009-09-09 15:08:12 +000053
Chris Lattnerf15970c2009-02-16 19:35:30 +000054 if (NamedDecl *ND = getCurFunctionOrMethodDecl()) {
55 // If this reference happens *in* a deprecated function or method, don't
56 // warn.
Chris Lattner52338262009-10-25 22:31:57 +000057 isSilenced |= ND->getAttr<DeprecatedAttr>() != 0;
Mike Stump1eb44332009-09-09 15:08:12 +000058
Chris Lattnerf15970c2009-02-16 19:35:30 +000059 // If this is an Objective-C method implementation, check to see if the
60 // method was deprecated on the declaration, not the definition.
61 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND)) {
62 // The semantic decl context of a ObjCMethodDecl is the
63 // ObjCImplementationDecl.
64 if (ObjCImplementationDecl *Impl
65 = dyn_cast<ObjCImplementationDecl>(MD->getParent())) {
Mike Stump1eb44332009-09-09 15:08:12 +000066
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +000067 MD = Impl->getClassInterface()->getMethod(MD->getSelector(),
Chris Lattnerf15970c2009-02-16 19:35:30 +000068 MD->isInstanceMethod());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +000069 isSilenced |= MD && MD->getAttr<DeprecatedAttr>();
Chris Lattnerf15970c2009-02-16 19:35:30 +000070 }
71 }
72 }
Mike Stump1eb44332009-09-09 15:08:12 +000073
Chris Lattnerf15970c2009-02-16 19:35:30 +000074 if (!isSilenced)
Chris Lattner76a642f2009-02-15 22:43:40 +000075 Diag(Loc, diag::warn_deprecated) << D->getDeclName();
76 }
77
Chris Lattnerffb93682009-10-25 17:21:40 +000078 // See if the decl is unavailable
79 if (D->getAttr<UnavailableAttr>()) {
80 Diag(Loc, diag::warn_unavailable) << D->getDeclName();
81 Diag(D->getLocation(), diag::note_unavailable_here) << 0;
82 }
83
Douglas Gregor48f3bb92009-02-18 21:56:37 +000084 // See if this is a deleted function.
Douglas Gregor25d944a2009-02-24 04:26:15 +000085 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Douglas Gregor48f3bb92009-02-18 21:56:37 +000086 if (FD->isDeleted()) {
87 Diag(Loc, diag::err_deleted_function_use);
88 Diag(D->getLocation(), diag::note_unavailable_here) << true;
89 return true;
90 }
Douglas Gregor25d944a2009-02-24 04:26:15 +000091 }
Douglas Gregor48f3bb92009-02-18 21:56:37 +000092
Douglas Gregor48f3bb92009-02-18 21:56:37 +000093 return false;
Chris Lattner76a642f2009-02-15 22:43:40 +000094}
95
Fariborz Jahanian5b530052009-05-13 18:09:35 +000096/// DiagnoseSentinelCalls - This routine checks on method dispatch calls
Mike Stump1eb44332009-09-09 15:08:12 +000097/// (and other functions in future), which have been declared with sentinel
Fariborz Jahanian5b530052009-05-13 18:09:35 +000098/// attribute. It warns if call does not have the sentinel argument.
99///
100void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +0000101 Expr **Args, unsigned NumArgs) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000102 const SentinelAttr *attr = D->getAttr<SentinelAttr>();
Mike Stump1eb44332009-09-09 15:08:12 +0000103 if (!attr)
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000104 return;
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000105 int sentinelPos = attr->getSentinel();
106 int nullPos = attr->getNullPos();
Mike Stump1eb44332009-09-09 15:08:12 +0000107
Mike Stump390b4cc2009-05-16 07:39:55 +0000108 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common
109 // base class. Then we won't be needing two versions of the same code.
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000110 unsigned int i = 0;
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000111 bool warnNotEnoughArgs = false;
112 int isMethod = 0;
113 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
114 // skip over named parameters.
115 ObjCMethodDecl::param_iterator P, E = MD->param_end();
116 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) {
117 if (nullPos)
118 --nullPos;
119 else
120 ++i;
121 }
122 warnNotEnoughArgs = (P != E || i >= NumArgs);
123 isMethod = 1;
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000124 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000125 // skip over named parameters.
126 ObjCMethodDecl::param_iterator P, E = FD->param_end();
127 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) {
128 if (nullPos)
129 --nullPos;
130 else
131 ++i;
132 }
133 warnNotEnoughArgs = (P != E || i >= NumArgs);
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000134 } else if (VarDecl *V = dyn_cast<VarDecl>(D)) {
Fariborz Jahaniandaf04152009-05-15 20:33:25 +0000135 // block or function pointer call.
136 QualType Ty = V->getType();
137 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
Mike Stump1eb44332009-09-09 15:08:12 +0000138 const FunctionType *FT = Ty->isFunctionPointerType()
John McCall183700f2009-09-21 23:43:11 +0000139 ? Ty->getAs<PointerType>()->getPointeeType()->getAs<FunctionType>()
140 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
Fariborz Jahaniandaf04152009-05-15 20:33:25 +0000141 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) {
142 unsigned NumArgsInProto = Proto->getNumArgs();
143 unsigned k;
144 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) {
145 if (nullPos)
146 --nullPos;
147 else
148 ++i;
149 }
150 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs);
151 }
152 if (Ty->isBlockPointerType())
153 isMethod = 2;
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000154 } else
Fariborz Jahaniandaf04152009-05-15 20:33:25 +0000155 return;
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000156 } else
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000157 return;
158
159 if (warnNotEnoughArgs) {
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000160 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000161 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000162 return;
163 }
164 int sentinel = i;
165 while (sentinelPos > 0 && i < NumArgs-1) {
166 --sentinelPos;
167 ++i;
168 }
169 if (sentinelPos > 0) {
170 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000171 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000172 return;
173 }
174 while (i < NumArgs-1) {
175 ++i;
176 ++sentinel;
177 }
178 Expr *sentinelExpr = Args[sentinel];
179 if (sentinelExpr && (!sentinelExpr->getType()->isPointerType() ||
Douglas Gregorce940492009-09-25 04:25:58 +0000180 !sentinelExpr->isNullPointerConstant(Context,
181 Expr::NPC_ValueDependentIsNull))) {
Fariborz Jahaniandaf04152009-05-15 20:33:25 +0000182 Diag(Loc, diag::warn_missing_sentinel) << isMethod;
Fariborz Jahanian236673e2009-05-14 18:00:00 +0000183 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
Fariborz Jahanian88f1ba02009-05-13 23:20:50 +0000184 }
185 return;
Fariborz Jahanian5b530052009-05-13 18:09:35 +0000186}
187
Douglas Gregor4b2d3f72009-02-26 21:00:50 +0000188SourceRange Sema::getExprRange(ExprTy *E) const {
189 Expr *Ex = (Expr *)E;
190 return Ex? Ex->getSourceRange() : SourceRange();
191}
192
Chris Lattnere7a2e912008-07-25 21:10:04 +0000193//===----------------------------------------------------------------------===//
194// Standard Promotions and Conversions
195//===----------------------------------------------------------------------===//
196
Chris Lattnere7a2e912008-07-25 21:10:04 +0000197/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
198void Sema::DefaultFunctionArrayConversion(Expr *&E) {
199 QualType Ty = E->getType();
200 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
201
Chris Lattnere7a2e912008-07-25 21:10:04 +0000202 if (Ty->isFunctionType())
Mike Stump1eb44332009-09-09 15:08:12 +0000203 ImpCastExprToType(E, Context.getPointerType(Ty),
Anders Carlssonb633c4e2009-09-01 20:37:18 +0000204 CastExpr::CK_FunctionToPointerDecay);
Chris Lattner67d33d82008-07-25 21:33:13 +0000205 else if (Ty->isArrayType()) {
206 // In C90 mode, arrays only promote to pointers if the array expression is
207 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
208 // type 'array of type' is converted to an expression that has type 'pointer
209 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
210 // that has type 'array of type' ...". The relevant change is "an lvalue"
211 // (C90) to "an expression" (C99).
Argyrios Kyrtzidisc39a3d72008-09-11 04:25:59 +0000212 //
213 // C++ 4.2p1:
214 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
215 // T" can be converted to an rvalue of type "pointer to T".
216 //
217 if (getLangOptions().C99 || getLangOptions().CPlusPlus ||
218 E->isLvalue(Context) == Expr::LV_Valid)
Anders Carlsson112a0a82009-08-07 23:48:20 +0000219 ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
220 CastExpr::CK_ArrayToPointerDecay);
Chris Lattner67d33d82008-07-25 21:33:13 +0000221 }
Chris Lattnere7a2e912008-07-25 21:10:04 +0000222}
223
224/// UsualUnaryConversions - Performs various conversions that are common to most
Mike Stump1eb44332009-09-09 15:08:12 +0000225/// operators (C99 6.3). The conversions of array and function types are
Chris Lattnere7a2e912008-07-25 21:10:04 +0000226/// sometimes surpressed. For example, the array->pointer conversion doesn't
227/// apply if the array is an argument to the sizeof or address (&) operators.
228/// In these instances, this routine should *not* be called.
229Expr *Sema::UsualUnaryConversions(Expr *&Expr) {
230 QualType Ty = Expr->getType();
231 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
Mike Stump1eb44332009-09-09 15:08:12 +0000232
Douglas Gregorfc24e442009-05-01 20:41:21 +0000233 // C99 6.3.1.1p2:
234 //
235 // The following may be used in an expression wherever an int or
236 // unsigned int may be used:
237 // - an object or expression with an integer type whose integer
238 // conversion rank is less than or equal to the rank of int
239 // and unsigned int.
240 // - A bit-field of type _Bool, int, signed int, or unsigned int.
241 //
242 // If an int can represent all values of the original type, the
243 // value is converted to an int; otherwise, it is converted to an
244 // unsigned int. These are called the integer promotions. All
245 // other types are unchanged by the integer promotions.
Eli Friedman04e83572009-08-20 04:21:42 +0000246 QualType PTy = Context.isPromotableBitField(Expr);
247 if (!PTy.isNull()) {
Eli Friedman73c39ab2009-10-20 08:27:19 +0000248 ImpCastExprToType(Expr, PTy, CastExpr::CK_IntegralCast);
Eli Friedman04e83572009-08-20 04:21:42 +0000249 return Expr;
250 }
Douglas Gregorfc24e442009-05-01 20:41:21 +0000251 if (Ty->isPromotableIntegerType()) {
Eli Friedmana95d7572009-08-19 07:44:53 +0000252 QualType PT = Context.getPromotedIntegerType(Ty);
Eli Friedman73c39ab2009-10-20 08:27:19 +0000253 ImpCastExprToType(Expr, PT, CastExpr::CK_IntegralCast);
Douglas Gregorfc24e442009-05-01 20:41:21 +0000254 return Expr;
Eli Friedman04e83572009-08-20 04:21:42 +0000255 }
256
Douglas Gregorfc24e442009-05-01 20:41:21 +0000257 DefaultFunctionArrayConversion(Expr);
Chris Lattnere7a2e912008-07-25 21:10:04 +0000258 return Expr;
259}
260
Chris Lattner05faf172008-07-25 22:25:12 +0000261/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
Mike Stump1eb44332009-09-09 15:08:12 +0000262/// do not have a prototype. Arguments that have type float are promoted to
Chris Lattner05faf172008-07-25 22:25:12 +0000263/// double. All other argument types are converted by UsualUnaryConversions().
264void Sema::DefaultArgumentPromotion(Expr *&Expr) {
265 QualType Ty = Expr->getType();
266 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
Mike Stump1eb44332009-09-09 15:08:12 +0000267
Chris Lattner05faf172008-07-25 22:25:12 +0000268 // If this is a 'float' (CVR qualified or typedef) promote to double.
John McCall183700f2009-09-21 23:43:11 +0000269 if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
Chris Lattner05faf172008-07-25 22:25:12 +0000270 if (BT->getKind() == BuiltinType::Float)
Eli Friedman73c39ab2009-10-20 08:27:19 +0000271 return ImpCastExprToType(Expr, Context.DoubleTy,
272 CastExpr::CK_FloatingCast);
Mike Stump1eb44332009-09-09 15:08:12 +0000273
Chris Lattner05faf172008-07-25 22:25:12 +0000274 UsualUnaryConversions(Expr);
275}
276
Chris Lattner312531a2009-04-12 08:11:20 +0000277/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
278/// will warn if the resulting type is not a POD type, and rejects ObjC
279/// interfaces passed by value. This returns true if the argument type is
280/// completely illegal.
281bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT) {
Anders Carlssondce5e2c2009-01-16 16:48:51 +0000282 DefaultArgumentPromotion(Expr);
Mike Stump1eb44332009-09-09 15:08:12 +0000283
Chris Lattner312531a2009-04-12 08:11:20 +0000284 if (Expr->getType()->isObjCInterfaceType()) {
285 Diag(Expr->getLocStart(),
286 diag::err_cannot_pass_objc_interface_to_vararg)
287 << Expr->getType() << CT;
288 return true;
Anders Carlssondce5e2c2009-01-16 16:48:51 +0000289 }
Mike Stump1eb44332009-09-09 15:08:12 +0000290
Chris Lattner312531a2009-04-12 08:11:20 +0000291 if (!Expr->getType()->isPODType())
292 Diag(Expr->getLocStart(), diag::warn_cannot_pass_non_pod_arg_to_vararg)
293 << Expr->getType() << CT;
294
295 return false;
Anders Carlssondce5e2c2009-01-16 16:48:51 +0000296}
297
298
Chris Lattnere7a2e912008-07-25 21:10:04 +0000299/// UsualArithmeticConversions - Performs various conversions that are common to
300/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
Mike Stump1eb44332009-09-09 15:08:12 +0000301/// routine returns the first non-arithmetic type found. The client is
Chris Lattnere7a2e912008-07-25 21:10:04 +0000302/// responsible for emitting appropriate error diagnostics.
303/// FIXME: verify the conversion rules for "complex int" are consistent with
304/// GCC.
305QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
306 bool isCompAssign) {
Eli Friedmanab3a8522009-03-28 01:22:36 +0000307 if (!isCompAssign)
Chris Lattnere7a2e912008-07-25 21:10:04 +0000308 UsualUnaryConversions(lhsExpr);
Eli Friedmanab3a8522009-03-28 01:22:36 +0000309
310 UsualUnaryConversions(rhsExpr);
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000311
Mike Stump1eb44332009-09-09 15:08:12 +0000312 // For conversion purposes, we ignore any qualifiers.
Chris Lattnere7a2e912008-07-25 21:10:04 +0000313 // For example, "const float" and "float" are equivalent.
Chris Lattnerb77792e2008-07-26 22:17:49 +0000314 QualType lhs =
315 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
Mike Stump1eb44332009-09-09 15:08:12 +0000316 QualType rhs =
Chris Lattnerb77792e2008-07-26 22:17:49 +0000317 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000318
319 // If both types are identical, no conversion is needed.
320 if (lhs == rhs)
321 return lhs;
322
323 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
324 // The caller can deal with this (e.g. pointer + int).
325 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
326 return lhs;
327
Douglas Gregor2d833e32009-05-02 00:36:19 +0000328 // Perform bitfield promotions.
Eli Friedman04e83572009-08-20 04:21:42 +0000329 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(lhsExpr);
Douglas Gregor2d833e32009-05-02 00:36:19 +0000330 if (!LHSBitfieldPromoteTy.isNull())
331 lhs = LHSBitfieldPromoteTy;
Eli Friedman04e83572009-08-20 04:21:42 +0000332 QualType RHSBitfieldPromoteTy = Context.isPromotableBitField(rhsExpr);
Douglas Gregor2d833e32009-05-02 00:36:19 +0000333 if (!RHSBitfieldPromoteTy.isNull())
334 rhs = RHSBitfieldPromoteTy;
335
Eli Friedmana95d7572009-08-19 07:44:53 +0000336 QualType destType = Context.UsualArithmeticConversionsType(lhs, rhs);
Eli Friedmanab3a8522009-03-28 01:22:36 +0000337 if (!isCompAssign)
Eli Friedman73c39ab2009-10-20 08:27:19 +0000338 ImpCastExprToType(lhsExpr, destType, CastExpr::CK_Unknown);
339 ImpCastExprToType(rhsExpr, destType, CastExpr::CK_Unknown);
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000340 return destType;
341}
342
Chris Lattnere7a2e912008-07-25 21:10:04 +0000343//===----------------------------------------------------------------------===//
344// Semantic Analysis for various Expression Types
345//===----------------------------------------------------------------------===//
346
347
Steve Narofff69936d2007-09-16 03:34:24 +0000348/// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +0000349/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
350/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
351/// multiple tokens. However, the common case is that StringToks points to one
352/// string.
Sebastian Redlcd965b92009-01-18 18:53:16 +0000353///
354Action::OwningExprResult
Steve Narofff69936d2007-09-16 03:34:24 +0000355Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000356 assert(NumStringToks && "Must have at least one string!");
357
Chris Lattnerbbee00b2009-01-16 18:51:42 +0000358 StringLiteralParser Literal(StringToks, NumStringToks, PP);
Reid Spencer5f016e22007-07-11 17:01:13 +0000359 if (Literal.hadError)
Sebastian Redlcd965b92009-01-18 18:53:16 +0000360 return ExprError();
Reid Spencer5f016e22007-07-11 17:01:13 +0000361
362 llvm::SmallVector<SourceLocation, 4> StringTokLocs;
363 for (unsigned i = 0; i != NumStringToks; ++i)
364 StringTokLocs.push_back(StringToks[i].getLocation());
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000365
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000366 QualType StrTy = Context.CharTy;
Argyrios Kyrtzidis55f4b022008-08-09 17:20:01 +0000367 if (Literal.AnyWide) StrTy = Context.getWCharType();
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000368 if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
Douglas Gregor77a52232008-09-12 00:47:35 +0000369
370 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
371 if (getLangOptions().CPlusPlus)
372 StrTy.addConst();
Sebastian Redlcd965b92009-01-18 18:53:16 +0000373
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000374 // Get an array type for the string, according to C99 6.4.5. This includes
375 // the nul terminator character as well as the string length for pascal
376 // strings.
377 StrTy = Context.getConstantArrayType(StrTy,
Chris Lattnerdbb1ecc2009-02-26 23:01:51 +0000378 llvm::APInt(32, Literal.GetNumStringChars()+1),
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000379 ArrayType::Normal, 0);
Mike Stump1eb44332009-09-09 15:08:12 +0000380
Reid Spencer5f016e22007-07-11 17:01:13 +0000381 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
Mike Stump1eb44332009-09-09 15:08:12 +0000382 return Owned(StringLiteral::Create(Context, Literal.GetString(),
Chris Lattner2085fd62009-02-18 06:40:38 +0000383 Literal.GetStringLength(),
384 Literal.AnyWide, StrTy,
385 &StringTokLocs[0],
386 StringTokLocs.size()));
Reid Spencer5f016e22007-07-11 17:01:13 +0000387}
388
Chris Lattner639e2d32008-10-20 05:16:36 +0000389/// ShouldSnapshotBlockValueReference - Return true if a reference inside of
390/// CurBlock to VD should cause it to be snapshotted (as we do for auto
391/// variables defined outside the block) or false if this is not needed (e.g.
392/// for values inside the block or for globals).
393///
Chris Lattner17f3a6d2009-04-21 22:26:47 +0000394/// This also keeps the 'hasBlockDeclRefExprs' in the BlockSemaInfo records
395/// up-to-date.
396///
Chris Lattner639e2d32008-10-20 05:16:36 +0000397static bool ShouldSnapshotBlockValueReference(BlockSemaInfo *CurBlock,
398 ValueDecl *VD) {
399 // If the value is defined inside the block, we couldn't snapshot it even if
400 // we wanted to.
401 if (CurBlock->TheDecl == VD->getDeclContext())
402 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000403
Chris Lattner639e2d32008-10-20 05:16:36 +0000404 // If this is an enum constant or function, it is constant, don't snapshot.
405 if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD))
406 return false;
407
408 // If this is a reference to an extern, static, or global variable, no need to
409 // snapshot it.
410 // FIXME: What about 'const' variables in C++?
411 if (const VarDecl *Var = dyn_cast<VarDecl>(VD))
Chris Lattner17f3a6d2009-04-21 22:26:47 +0000412 if (!Var->hasLocalStorage())
413 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000414
Chris Lattner17f3a6d2009-04-21 22:26:47 +0000415 // Blocks that have these can't be constant.
416 CurBlock->hasBlockDeclRefExprs = true;
417
418 // If we have nested blocks, the decl may be declared in an outer block (in
419 // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may
420 // be defined outside all of the current blocks (in which case the blocks do
421 // all get the bit). Walk the nesting chain.
422 for (BlockSemaInfo *NextBlock = CurBlock->PrevBlockInfo; NextBlock;
423 NextBlock = NextBlock->PrevBlockInfo) {
424 // If we found the defining block for the variable, don't mark the block as
425 // having a reference outside it.
426 if (NextBlock->TheDecl == VD->getDeclContext())
427 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000428
Chris Lattner17f3a6d2009-04-21 22:26:47 +0000429 // Otherwise, the DeclRef from the inner block causes the outer one to need
430 // a snapshot as well.
431 NextBlock->hasBlockDeclRefExprs = true;
432 }
Mike Stump1eb44332009-09-09 15:08:12 +0000433
Chris Lattner639e2d32008-10-20 05:16:36 +0000434 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000435}
436
Chris Lattner639e2d32008-10-20 05:16:36 +0000437
438
Steve Naroff08d92e42007-09-15 18:49:24 +0000439/// ActOnIdentifierExpr - The parser read an identifier in expression context,
Reid Spencer5f016e22007-07-11 17:01:13 +0000440/// validate it per-C99 6.5.1. HasTrailingLParen indicates whether this
Steve Naroff0d755ad2008-03-19 23:46:26 +0000441/// identifier is used in a function call context.
Sebastian Redlcd965b92009-01-18 18:53:16 +0000442/// SS is only used for a C++ qualified-id (foo::bar) to indicate the
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000443/// class or namespace that the identifier must be a member of.
Sebastian Redlcd965b92009-01-18 18:53:16 +0000444Sema::OwningExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
445 IdentifierInfo &II,
446 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +0000447 const CXXScopeSpec *SS,
448 bool isAddressOfOperand) {
449 return ActOnDeclarationNameExpr(S, Loc, &II, HasTrailingLParen, SS,
Douglas Gregor17330012009-02-04 15:01:18 +0000450 isAddressOfOperand);
Douglas Gregor10c42622008-11-18 15:03:34 +0000451}
452
Douglas Gregora2813ce2009-10-23 18:54:35 +0000453/// BuildDeclRefExpr - Build a DeclRefExpr.
Anders Carlssone41590d2009-06-24 00:10:43 +0000454Sema::OwningExprResult
Sebastian Redlebc07d52009-02-03 20:19:35 +0000455Sema::BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
456 bool TypeDependent, bool ValueDependent,
457 const CXXScopeSpec *SS) {
Anders Carlssone2bb2242009-06-26 19:16:07 +0000458 if (Context.getCanonicalType(Ty) == Context.UndeducedAutoTy) {
459 Diag(Loc,
Mike Stump1eb44332009-09-09 15:08:12 +0000460 diag::err_auto_variable_cannot_appear_in_own_initializer)
Anders Carlssone2bb2242009-06-26 19:16:07 +0000461 << D->getDeclName();
462 return ExprError();
463 }
Mike Stump1eb44332009-09-09 15:08:12 +0000464
Anders Carlssone41590d2009-06-24 00:10:43 +0000465 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
466 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
467 if (const FunctionDecl *FD = MD->getParent()->isLocalClass()) {
468 if (VD->hasLocalStorage() && VD->getDeclContext() != CurContext) {
Mike Stump1eb44332009-09-09 15:08:12 +0000469 Diag(Loc, diag::err_reference_to_local_var_in_enclosing_function)
Anders Carlssone41590d2009-06-24 00:10:43 +0000470 << D->getIdentifier() << FD->getDeclName();
Mike Stump1eb44332009-09-09 15:08:12 +0000471 Diag(D->getLocation(), diag::note_local_variable_declared_here)
Anders Carlssone41590d2009-06-24 00:10:43 +0000472 << D->getIdentifier();
473 return ExprError();
474 }
475 }
476 }
477 }
Mike Stump1eb44332009-09-09 15:08:12 +0000478
Douglas Gregore0762c92009-06-19 23:52:42 +0000479 MarkDeclarationReferenced(Loc, D);
Mike Stump1eb44332009-09-09 15:08:12 +0000480
Douglas Gregora2813ce2009-10-23 18:54:35 +0000481 return Owned(DeclRefExpr::Create(Context,
482 SS? (NestedNameSpecifier *)SS->getScopeRep() : 0,
483 SS? SS->getRange() : SourceRange(),
484 D, Loc,
485 Ty, TypeDependent, ValueDependent));
Douglas Gregor1a49af92009-01-06 05:10:23 +0000486}
487
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000488/// getObjectForAnonymousRecordDecl - Retrieve the (unnamed) field or
489/// variable corresponding to the anonymous union or struct whose type
490/// is Record.
Douglas Gregor6ab35242009-04-09 21:40:53 +0000491static Decl *getObjectForAnonymousRecordDecl(ASTContext &Context,
492 RecordDecl *Record) {
Mike Stump1eb44332009-09-09 15:08:12 +0000493 assert(Record->isAnonymousStructOrUnion() &&
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000494 "Record must be an anonymous struct or union!");
Mike Stump1eb44332009-09-09 15:08:12 +0000495
Mike Stump390b4cc2009-05-16 07:39:55 +0000496 // FIXME: Once Decls are directly linked together, this will be an O(1)
497 // operation rather than a slow walk through DeclContext's vector (which
498 // itself will be eliminated). DeclGroups might make this even better.
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000499 DeclContext *Ctx = Record->getDeclContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000500 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000501 DEnd = Ctx->decls_end();
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000502 D != DEnd; ++D) {
503 if (*D == Record) {
504 // The object for the anonymous struct/union directly
505 // follows its type in the list of declarations.
506 ++D;
507 assert(D != DEnd && "Missing object for anonymous record");
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000508 assert(!cast<NamedDecl>(*D)->getDeclName() && "Decl should be unnamed");
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000509 return *D;
510 }
511 }
512
513 assert(false && "Missing object for anonymous record");
514 return 0;
515}
516
Douglas Gregorffb4b6e2009-04-15 06:41:24 +0000517/// \brief Given a field that represents a member of an anonymous
518/// struct/union, build the path from that field's context to the
519/// actual member.
520///
521/// Construct the sequence of field member references we'll have to
522/// perform to get to the field in the anonymous union/struct. The
523/// list of members is built from the field outward, so traverse it
524/// backwards to go from an object in the current context to the field
525/// we found.
526///
527/// \returns The variable from which the field access should begin,
528/// for an anonymous struct/union that is not a member of another
529/// class. Otherwise, returns NULL.
530VarDecl *Sema::BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
531 llvm::SmallVectorImpl<FieldDecl *> &Path) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000532 assert(Field->getDeclContext()->isRecord() &&
533 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion()
534 && "Field must be stored inside an anonymous struct or union");
535
Douglas Gregorffb4b6e2009-04-15 06:41:24 +0000536 Path.push_back(Field);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000537 VarDecl *BaseObject = 0;
538 DeclContext *Ctx = Field->getDeclContext();
539 do {
540 RecordDecl *Record = cast<RecordDecl>(Ctx);
Douglas Gregor6ab35242009-04-09 21:40:53 +0000541 Decl *AnonObject = getObjectForAnonymousRecordDecl(Context, Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000542 if (FieldDecl *AnonField = dyn_cast<FieldDecl>(AnonObject))
Douglas Gregorffb4b6e2009-04-15 06:41:24 +0000543 Path.push_back(AnonField);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000544 else {
545 BaseObject = cast<VarDecl>(AnonObject);
546 break;
547 }
548 Ctx = Ctx->getParent();
Mike Stump1eb44332009-09-09 15:08:12 +0000549 } while (Ctx->isRecord() &&
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000550 cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion());
Douglas Gregorffb4b6e2009-04-15 06:41:24 +0000551
552 return BaseObject;
553}
554
555Sema::OwningExprResult
556Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
557 FieldDecl *Field,
558 Expr *BaseObjectExpr,
559 SourceLocation OpLoc) {
560 llvm::SmallVector<FieldDecl *, 4> AnonFields;
Mike Stump1eb44332009-09-09 15:08:12 +0000561 VarDecl *BaseObject = BuildAnonymousStructUnionMemberPath(Field,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +0000562 AnonFields);
563
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000564 // Build the expression that refers to the base object, from
565 // which we will build a sequence of member references to each
566 // of the anonymous union objects and, eventually, the field we
567 // found via name lookup.
568 bool BaseObjectIsPointer = false;
John McCall0953e762009-09-24 19:53:00 +0000569 Qualifiers BaseQuals;
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000570 if (BaseObject) {
571 // BaseObject is an anonymous struct/union variable (and is,
572 // therefore, not part of another non-anonymous record).
Ted Kremenek8189cde2009-02-07 01:47:29 +0000573 if (BaseObjectExpr) BaseObjectExpr->Destroy(Context);
Douglas Gregore0762c92009-06-19 23:52:42 +0000574 MarkDeclarationReferenced(Loc, BaseObject);
Steve Naroff6ece14c2009-01-21 00:14:39 +0000575 BaseObjectExpr = new (Context) DeclRefExpr(BaseObject,BaseObject->getType(),
Mike Stumpeed9cac2009-02-19 03:04:26 +0000576 SourceLocation());
John McCall0953e762009-09-24 19:53:00 +0000577 BaseQuals
578 = Context.getCanonicalType(BaseObject->getType()).getQualifiers();
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000579 } else if (BaseObjectExpr) {
580 // The caller provided the base object expression. Determine
581 // whether its a pointer and whether it adds any qualifiers to the
582 // anonymous struct/union fields we're looking into.
583 QualType ObjectType = BaseObjectExpr->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000584 if (const PointerType *ObjectPtr = ObjectType->getAs<PointerType>()) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000585 BaseObjectIsPointer = true;
586 ObjectType = ObjectPtr->getPointeeType();
587 }
John McCall0953e762009-09-24 19:53:00 +0000588 BaseQuals
589 = Context.getCanonicalType(ObjectType).getQualifiers();
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000590 } else {
591 // We've found a member of an anonymous struct/union that is
592 // inside a non-anonymous struct/union, so in a well-formed
593 // program our base object expression is "this".
594 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
595 if (!MD->isStatic()) {
Mike Stump1eb44332009-09-09 15:08:12 +0000596 QualType AnonFieldType
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000597 = Context.getTagDeclType(
598 cast<RecordDecl>(AnonFields.back()->getDeclContext()));
599 QualType ThisType = Context.getTagDeclType(MD->getParent());
Mike Stump1eb44332009-09-09 15:08:12 +0000600 if ((Context.getCanonicalType(AnonFieldType)
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000601 == Context.getCanonicalType(ThisType)) ||
602 IsDerivedFrom(ThisType, AnonFieldType)) {
603 // Our base object expression is "this".
Steve Naroff6ece14c2009-01-21 00:14:39 +0000604 BaseObjectExpr = new (Context) CXXThisExpr(SourceLocation(),
Mike Stumpeed9cac2009-02-19 03:04:26 +0000605 MD->getThisType(Context));
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000606 BaseObjectIsPointer = true;
607 }
608 } else {
Sebastian Redlcd965b92009-01-18 18:53:16 +0000609 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
610 << Field->getDeclName());
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000611 }
John McCall0953e762009-09-24 19:53:00 +0000612 BaseQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000613 }
614
Mike Stump1eb44332009-09-09 15:08:12 +0000615 if (!BaseObjectExpr)
Sebastian Redlcd965b92009-01-18 18:53:16 +0000616 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
617 << Field->getDeclName());
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000618 }
619
620 // Build the implicit member references to the field of the
621 // anonymous struct/union.
622 Expr *Result = BaseObjectExpr;
John McCall0953e762009-09-24 19:53:00 +0000623 Qualifiers ResultQuals = BaseQuals;
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000624 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
625 FI = AnonFields.rbegin(), FIEnd = AnonFields.rend();
626 FI != FIEnd; ++FI) {
627 QualType MemberType = (*FI)->getType();
John McCall0953e762009-09-24 19:53:00 +0000628 Qualifiers MemberTypeQuals =
629 Context.getCanonicalType(MemberType).getQualifiers();
630
631 // CVR attributes from the base are picked up by members,
632 // except that 'mutable' members don't pick up 'const'.
633 if ((*FI)->isMutable())
634 ResultQuals.removeConst();
635
636 // GC attributes are never picked up by members.
637 ResultQuals.removeObjCGCAttr();
638
639 // TR 18037 does not allow fields to be declared with address spaces.
640 assert(!MemberTypeQuals.hasAddressSpace());
641
642 Qualifiers NewQuals = ResultQuals + MemberTypeQuals;
643 if (NewQuals != MemberTypeQuals)
644 MemberType = Context.getQualifiedType(MemberType, NewQuals);
645
Douglas Gregore0762c92009-06-19 23:52:42 +0000646 MarkDeclarationReferenced(Loc, *FI);
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000647 // FIXME: Might this end up being a qualified name?
Steve Naroff6ece14c2009-01-21 00:14:39 +0000648 Result = new (Context) MemberExpr(Result, BaseObjectIsPointer, *FI,
649 OpLoc, MemberType);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000650 BaseObjectIsPointer = false;
John McCall0953e762009-09-24 19:53:00 +0000651 ResultQuals = NewQuals;
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000652 }
653
Sebastian Redlcd965b92009-01-18 18:53:16 +0000654 return Owned(Result);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000655}
656
Douglas Gregor10c42622008-11-18 15:03:34 +0000657/// ActOnDeclarationNameExpr - The parser has read some kind of name
658/// (e.g., a C++ id-expression (C++ [expr.prim]p1)). This routine
659/// performs lookup on that name and returns an expression that refers
660/// to that name. This routine isn't directly called from the parser,
661/// because the parser doesn't know about DeclarationName. Rather,
662/// this routine is called by ActOnIdentifierExpr,
663/// ActOnOperatorFunctionIdExpr, and ActOnConversionFunctionExpr,
664/// which form the DeclarationName from the corresponding syntactic
665/// forms.
666///
667/// HasTrailingLParen indicates whether this identifier is used in a
668/// function call context. LookupCtx is only used for a C++
669/// qualified-id (foo::bar) to indicate the class or namespace that
670/// the identifier must be a member of.
Douglas Gregor5c37de72008-12-06 00:22:45 +0000671///
Sebastian Redlebc07d52009-02-03 20:19:35 +0000672/// isAddressOfOperand means that this expression is the direct operand
673/// of an address-of operator. This matters because this is the only
674/// situation where a qualified name referencing a non-static member may
675/// appear outside a member function of this class.
Sebastian Redlcd965b92009-01-18 18:53:16 +0000676Sema::OwningExprResult
677Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
678 DeclarationName Name, bool HasTrailingLParen,
Mike Stump1eb44332009-09-09 15:08:12 +0000679 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +0000680 bool isAddressOfOperand) {
Chris Lattner8a934232008-03-31 00:36:02 +0000681 // Could be enum-constant, value decl, instance variable, etc.
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000682 if (SS && SS->isInvalid())
683 return ExprError();
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000684
685 // C++ [temp.dep.expr]p3:
686 // An id-expression is type-dependent if it contains:
687 // -- a nested-name-specifier that contains a class-name that
688 // names a dependent type.
Douglas Gregor00c44862009-05-29 14:49:33 +0000689 // FIXME: Member of the current instantiation.
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000690 if (SS && isDependentScopeSpecifier(*SS)) {
Douglas Gregorab452ba2009-03-26 23:50:42 +0000691 return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy,
Mike Stump1eb44332009-09-09 15:08:12 +0000692 Loc, SS->getRange(),
Anders Carlsson9b31df42009-07-09 00:05:08 +0000693 static_cast<NestedNameSpecifier *>(SS->getScopeRep()),
694 isAddressOfOperand));
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000695 }
696
John McCallf36e02d2009-10-09 21:13:30 +0000697 LookupResult Lookup;
698 LookupParsedName(Lookup, S, SS, Name, LookupOrdinaryName, false, true, Loc);
Douglas Gregor7176fff2009-01-15 00:26:24 +0000699
Sebastian Redlcd965b92009-01-18 18:53:16 +0000700 if (Lookup.isAmbiguous()) {
701 DiagnoseAmbiguousLookup(Lookup, Name, Loc,
702 SS && SS->isSet() ? SS->getRange()
703 : SourceRange());
704 return ExprError();
Chris Lattner5cb10d32009-04-24 22:30:50 +0000705 }
Mike Stump1eb44332009-09-09 15:08:12 +0000706
John McCallf36e02d2009-10-09 21:13:30 +0000707 NamedDecl *D = Lookup.getAsSingleDecl(Context);
Douglas Gregor5c37de72008-12-06 00:22:45 +0000708
Chris Lattner8a934232008-03-31 00:36:02 +0000709 // If this reference is in an Objective-C method, then ivar lookup happens as
710 // well.
Douglas Gregor10c42622008-11-18 15:03:34 +0000711 IdentifierInfo *II = Name.getAsIdentifierInfo();
712 if (II && getCurMethodDecl()) {
Chris Lattner8a934232008-03-31 00:36:02 +0000713 // There are two cases to handle here. 1) scoped lookup could have failed,
714 // in which case we should look for an ivar. 2) scoped lookup could have
Mike Stump1eb44332009-09-09 15:08:12 +0000715 // found a decl, but that decl is outside the current instance method (i.e.
716 // a global variable). In these two cases, we do a lookup for an ivar with
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000717 // this name, if the lookup sucedes, we replace it our current decl.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000718 if (D == 0 || D->isDefinedOutsideFunctionOrMethod()) {
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000719 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
Fariborz Jahanian935fd762009-03-03 01:21:12 +0000720 ObjCInterfaceDecl *ClassDeclared;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000721 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
Chris Lattner553905d2009-02-16 17:19:12 +0000722 // Check if referencing a field with __attribute__((deprecated)).
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000723 if (DiagnoseUseOfDecl(IV, Loc))
724 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +0000725
Chris Lattner5cb10d32009-04-24 22:30:50 +0000726 // If we're referencing an invalid decl, just return this as a silent
727 // error node. The error diagnostic was already emitted on the decl.
728 if (IV->isInvalidDecl())
729 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +0000730
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000731 bool IsClsMethod = getCurMethodDecl()->isClassMethod();
732 // If a class method attemps to use a free standing ivar, this is
733 // an error.
734 if (IsClsMethod && D && !D->isDefinedOutsideFunctionOrMethod())
735 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
736 << IV->getDeclName());
737 // If a class method uses a global variable, even if an ivar with
738 // same name exists, use the global.
739 if (!IsClsMethod) {
Fariborz Jahanian935fd762009-03-03 01:21:12 +0000740 if (IV->getAccessControl() == ObjCIvarDecl::Private &&
741 ClassDeclared != IFace)
742 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
Mike Stump390b4cc2009-05-16 07:39:55 +0000743 // FIXME: This should use a new expr for a direct reference, don't
744 // turn this into Self->ivar, just return a BareIVarExpr or something.
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000745 IdentifierInfo &II = Context.Idents.get("self");
Argyrios Kyrtzidisecd1bae2009-07-18 08:49:37 +0000746 OwningExprResult SelfExpr = ActOnIdentifierExpr(S, SourceLocation(),
747 II, false);
Douglas Gregore0762c92009-06-19 23:52:42 +0000748 MarkDeclarationReferenced(Loc, IV);
Mike Stump1eb44332009-09-09 15:08:12 +0000749 return Owned(new (Context)
750 ObjCIvarRefExpr(IV, IV->getType(), Loc,
Anders Carlssone9146f22009-05-01 19:49:17 +0000751 SelfExpr.takeAs<Expr>(), true, true));
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000752 }
Chris Lattner8a934232008-03-31 00:36:02 +0000753 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000754 } else if (getCurMethodDecl()->isInstanceMethod()) {
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000755 // We should warn if a local variable hides an ivar.
756 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
Fariborz Jahanian935fd762009-03-03 01:21:12 +0000757 ObjCInterfaceDecl *ClassDeclared;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000758 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
Fariborz Jahanian935fd762009-03-03 01:21:12 +0000759 if (IV->getAccessControl() != ObjCIvarDecl::Private ||
760 IFace == ClassDeclared)
Chris Lattner5cb10d32009-04-24 22:30:50 +0000761 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
Fariborz Jahanian935fd762009-03-03 01:21:12 +0000762 }
Fariborz Jahanian077c1e72009-03-02 21:55:29 +0000763 }
Steve Naroff76de9d72008-08-10 19:10:41 +0000764 // Needed to implement property "super.method" notation.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000765 if (D == 0 && II->isStr("super")) {
Steve Naroffdd53eb52009-03-05 20:12:00 +0000766 QualType T;
Mike Stump1eb44332009-09-09 15:08:12 +0000767
Steve Naroffdd53eb52009-03-05 20:12:00 +0000768 if (getCurMethodDecl()->isInstanceMethod())
Steve Naroff14108da2009-07-10 23:34:53 +0000769 T = Context.getObjCObjectPointerType(Context.getObjCInterfaceType(
770 getCurMethodDecl()->getClassInterface()));
Steve Naroffdd53eb52009-03-05 20:12:00 +0000771 else
772 T = Context.getObjCClassType();
Steve Naroff6ece14c2009-01-21 00:14:39 +0000773 return Owned(new (Context) ObjCSuperExpr(Loc, T));
Steve Naroffe3e9add2008-06-02 23:03:37 +0000774 }
Chris Lattner8a934232008-03-31 00:36:02 +0000775 }
Douglas Gregorc71e28c2009-02-16 19:28:42 +0000776
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000777 // Determine whether this name might be a candidate for
778 // argument-dependent lookup.
Mike Stump1eb44332009-09-09 15:08:12 +0000779 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000780 HasTrailingLParen;
781
782 if (ADL && D == 0) {
Douglas Gregorc71e28c2009-02-16 19:28:42 +0000783 // We've seen something of the form
784 //
785 // identifier(
786 //
787 // and we did not find any entity by the name
788 // "identifier". However, this identifier is still subject to
789 // argument-dependent lookup, so keep track of the name.
790 return Owned(new (Context) UnresolvedFunctionNameExpr(Name,
791 Context.OverloadTy,
792 Loc));
793 }
794
Reid Spencer5f016e22007-07-11 17:01:13 +0000795 if (D == 0) {
796 // Otherwise, this could be an implicitly declared function reference (legal
797 // in C90, extension in C99).
Douglas Gregor10c42622008-11-18 15:03:34 +0000798 if (HasTrailingLParen && II &&
Chris Lattner8a934232008-03-31 00:36:02 +0000799 !getLangOptions().CPlusPlus) // Not in C++.
Douglas Gregor10c42622008-11-18 15:03:34 +0000800 D = ImplicitlyDefineFunction(Loc, *II, S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000801 else {
802 // If this name wasn't predeclared and if this is not a function call,
803 // diagnose the problem.
Douglas Gregor3f093272009-10-13 21:16:44 +0000804 if (SS && !SS->isEmpty())
805 return ExprError(Diag(Loc, diag::err_no_member)
806 << Name << computeDeclContext(*SS, false)
807 << SS->getRange());
808 else if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
Douglas Gregor10c42622008-11-18 15:03:34 +0000809 Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
Sebastian Redlcd965b92009-01-18 18:53:16 +0000810 return ExprError(Diag(Loc, diag::err_undeclared_use)
811 << Name.getAsString());
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000812 else
Sebastian Redlcd965b92009-01-18 18:53:16 +0000813 return ExprError(Diag(Loc, diag::err_undeclared_var_use) << Name);
Reid Spencer5f016e22007-07-11 17:01:13 +0000814 }
815 }
Mike Stump1eb44332009-09-09 15:08:12 +0000816
Douglas Gregor751f9a42009-06-30 15:47:41 +0000817 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
818 // Warn about constructs like:
819 // if (void *X = foo()) { ... } else { X }.
820 // In the else block, the pointer is always false.
Mike Stump1eb44332009-09-09 15:08:12 +0000821
Douglas Gregor751f9a42009-06-30 15:47:41 +0000822 // FIXME: In a template instantiation, we don't have scope
823 // information to check this property.
824 if (Var->isDeclaredInCondition() && Var->getType()->isScalarType()) {
825 Scope *CheckS = S;
826 while (CheckS) {
Mike Stump1eb44332009-09-09 15:08:12 +0000827 if (CheckS->isWithinElse() &&
Douglas Gregor751f9a42009-06-30 15:47:41 +0000828 CheckS->getControlParent()->isDeclScope(DeclPtrTy::make(Var))) {
829 if (Var->getType()->isBooleanType())
830 ExprError(Diag(Loc, diag::warn_value_always_false)
831 << Var->getDeclName());
832 else
833 ExprError(Diag(Loc, diag::warn_value_always_zero)
834 << Var->getDeclName());
835 break;
836 }
Mike Stump1eb44332009-09-09 15:08:12 +0000837
Douglas Gregor751f9a42009-06-30 15:47:41 +0000838 // Move up one more control parent to check again.
839 CheckS = CheckS->getControlParent();
840 if (CheckS)
841 CheckS = CheckS->getParent();
842 }
843 }
844 } else if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D)) {
845 if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) {
846 // C99 DR 316 says that, if a function type comes from a
847 // function definition (without a prototype), that type is only
848 // used for checking compatibility. Therefore, when referencing
849 // the function, we pretend that we don't have the full function
850 // type.
851 if (DiagnoseUseOfDecl(Func, Loc))
852 return ExprError();
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000853
Douglas Gregor751f9a42009-06-30 15:47:41 +0000854 QualType T = Func->getType();
855 QualType NoProtoType = T;
John McCall183700f2009-09-21 23:43:11 +0000856 if (const FunctionProtoType *Proto = T->getAs<FunctionProtoType>())
Douglas Gregor751f9a42009-06-30 15:47:41 +0000857 NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
858 return BuildDeclRefExpr(Func, NoProtoType, Loc, false, false, SS);
859 }
860 }
Mike Stump1eb44332009-09-09 15:08:12 +0000861
Douglas Gregor751f9a42009-06-30 15:47:41 +0000862 return BuildDeclarationNameExpr(Loc, D, HasTrailingLParen, SS, isAddressOfOperand);
863}
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000864/// \brief Cast member's object to its own class if necessary.
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000865bool
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000866Sema::PerformObjectMemberConversion(Expr *&From, NamedDecl *Member) {
867 if (FieldDecl *FD = dyn_cast<FieldDecl>(Member))
Mike Stump1eb44332009-09-09 15:08:12 +0000868 if (CXXRecordDecl *RD =
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000869 dyn_cast<CXXRecordDecl>(FD->getDeclContext())) {
Mike Stump1eb44332009-09-09 15:08:12 +0000870 QualType DestType =
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000871 Context.getCanonicalType(Context.getTypeDeclType(RD));
Fariborz Jahanian96e2fa92009-07-29 20:41:46 +0000872 if (DestType->isDependentType() || From->getType()->isDependentType())
873 return false;
874 QualType FromRecordType = From->getType();
875 QualType DestRecordType = DestType;
Ted Kremenek6217b802009-07-29 21:53:49 +0000876 if (FromRecordType->getAs<PointerType>()) {
Fariborz Jahanian96e2fa92009-07-29 20:41:46 +0000877 DestType = Context.getPointerType(DestType);
878 FromRecordType = FromRecordType->getPointeeType();
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000879 }
Fariborz Jahanian96e2fa92009-07-29 20:41:46 +0000880 if (!Context.hasSameUnqualifiedType(FromRecordType, DestRecordType) &&
881 CheckDerivedToBaseConversion(FromRecordType,
882 DestRecordType,
883 From->getSourceRange().getBegin(),
884 From->getSourceRange()))
885 return true;
Anders Carlsson3503d042009-07-31 01:23:52 +0000886 ImpCastExprToType(From, DestType, CastExpr::CK_DerivedToBase,
887 /*isLvalue=*/true);
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000888 }
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000889 return false;
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000890}
Douglas Gregor751f9a42009-06-30 15:47:41 +0000891
Douglas Gregor83f6faf2009-08-31 23:41:50 +0000892/// \brief Build a MemberExpr AST node.
Mike Stump1eb44332009-09-09 15:08:12 +0000893static MemberExpr *BuildMemberExpr(ASTContext &C, Expr *Base, bool isArrow,
894 const CXXScopeSpec *SS, NamedDecl *Member,
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000895 SourceLocation Loc, QualType Ty) {
896 if (SS && SS->isSet())
Mike Stump1eb44332009-09-09 15:08:12 +0000897 return MemberExpr::Create(C, Base, isArrow,
Douglas Gregor83f6faf2009-08-31 23:41:50 +0000898 (NestedNameSpecifier *)SS->getScopeRep(),
Mike Stump1eb44332009-09-09 15:08:12 +0000899 SS->getRange(), Member, Loc,
Douglas Gregorc4bf26f2009-09-01 00:37:14 +0000900 // FIXME: Explicit template argument lists
901 false, SourceLocation(), 0, 0, SourceLocation(),
902 Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000903
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000904 return new (C) MemberExpr(Base, isArrow, Member, Loc, Ty);
905}
906
Douglas Gregor751f9a42009-06-30 15:47:41 +0000907/// \brief Complete semantic analysis for a reference to the given declaration.
908Sema::OwningExprResult
909Sema::BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D,
910 bool HasTrailingLParen,
Mike Stump1eb44332009-09-09 15:08:12 +0000911 const CXXScopeSpec *SS,
Douglas Gregor751f9a42009-06-30 15:47:41 +0000912 bool isAddressOfOperand) {
913 assert(D && "Cannot refer to a NULL declaration");
914 DeclarationName Name = D->getDeclName();
Mike Stump1eb44332009-09-09 15:08:12 +0000915
Sebastian Redlebc07d52009-02-03 20:19:35 +0000916 // If this is an expression of the form &Class::member, don't build an
917 // implicit member ref, because we want a pointer to the member in general,
918 // not any specific instance's member.
919 if (isAddressOfOperand && SS && !SS->isEmpty() && !HasTrailingLParen) {
Douglas Gregore4e5b052009-03-19 00:18:19 +0000920 DeclContext *DC = computeDeclContext(*SS);
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000921 if (D && isa<CXXRecordDecl>(DC)) {
Sebastian Redlebc07d52009-02-03 20:19:35 +0000922 QualType DType;
923 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
924 DType = FD->getType().getNonReferenceType();
925 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
926 DType = Method->getType();
927 } else if (isa<OverloadedFunctionDecl>(D)) {
928 DType = Context.OverloadTy;
929 }
930 // Could be an inner type. That's diagnosed below, so ignore it here.
931 if (!DType.isNull()) {
932 // The pointer is type- and value-dependent if it points into something
933 // dependent.
Douglas Gregor00c44862009-05-29 14:49:33 +0000934 bool Dependent = DC->isDependentContext();
Anders Carlssone41590d2009-06-24 00:10:43 +0000935 return BuildDeclRefExpr(D, DType, Loc, Dependent, Dependent, SS);
Sebastian Redlebc07d52009-02-03 20:19:35 +0000936 }
937 }
938 }
939
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000940 // We may have found a field within an anonymous union or struct
941 // (C++ [class.union]).
Douglas Gregore961afb2009-10-22 07:08:30 +0000942 // FIXME: This needs to happen post-isImplicitMemberReference?
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000943 if (FieldDecl *FD = dyn_cast<FieldDecl>(D))
944 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
945 return BuildAnonymousStructUnionMemberReference(Loc, FD);
Sebastian Redlcd965b92009-01-18 18:53:16 +0000946
Douglas Gregore961afb2009-10-22 07:08:30 +0000947 // Cope with an implicit member access in a C++ non-static member function.
948 QualType ThisType, MemberType;
949 if (isImplicitMemberReference(SS, D, Loc, ThisType, MemberType)) {
950 Expr *This = new (Context) CXXThisExpr(SourceLocation(), ThisType);
951 MarkDeclarationReferenced(Loc, D);
952 if (PerformObjectMemberConversion(This, D))
953 return ExprError();
Douglas Gregor88a35142008-12-22 05:46:06 +0000954
Douglas Gregore961afb2009-10-22 07:08:30 +0000955 bool ShouldCheckUse = true;
956 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
957 // Don't diagnose the use of a virtual member function unless it's
958 // explicitly qualified.
959 if (MD->isVirtual() && (!SS || !SS->isSet()))
960 ShouldCheckUse = false;
Douglas Gregor88a35142008-12-22 05:46:06 +0000961 }
Douglas Gregore961afb2009-10-22 07:08:30 +0000962
963 if (ShouldCheckUse && DiagnoseUseOfDecl(D, Loc))
964 return ExprError();
965 return Owned(BuildMemberExpr(Context, This, true, SS, D,
966 Loc, MemberType));
Douglas Gregor88a35142008-12-22 05:46:06 +0000967 }
968
Douglas Gregor44b43212008-12-11 16:49:14 +0000969 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000970 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
971 if (MD->isStatic())
972 // "invalid use of member 'x' in static member function"
Sebastian Redlcd965b92009-01-18 18:53:16 +0000973 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
974 << FD->getDeclName());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000975 }
976
Douglas Gregor88a35142008-12-22 05:46:06 +0000977 // Any other ways we could have found the field in a well-formed
978 // program would have been turned into implicit member expressions
979 // above.
Sebastian Redlcd965b92009-01-18 18:53:16 +0000980 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
981 << FD->getDeclName());
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000982 }
Douglas Gregor88a35142008-12-22 05:46:06 +0000983
Reid Spencer5f016e22007-07-11 17:01:13 +0000984 if (isa<TypedefDecl>(D))
Sebastian Redlcd965b92009-01-18 18:53:16 +0000985 return ExprError(Diag(Loc, diag::err_unexpected_typedef) << Name);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000986 if (isa<ObjCInterfaceDecl>(D))
Sebastian Redlcd965b92009-01-18 18:53:16 +0000987 return ExprError(Diag(Loc, diag::err_unexpected_interface) << Name);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +0000988 if (isa<NamespaceDecl>(D))
Sebastian Redlcd965b92009-01-18 18:53:16 +0000989 return ExprError(Diag(Loc, diag::err_unexpected_namespace) << Name);
Reid Spencer5f016e22007-07-11 17:01:13 +0000990
Steve Naroffdd972f22008-09-05 22:11:13 +0000991 // Make the DeclRefExpr or BlockDeclRefExpr for the decl.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000992 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D))
Anders Carlssone41590d2009-06-24 00:10:43 +0000993 return BuildDeclRefExpr(Ovl, Context.OverloadTy, Loc,
994 false, false, SS);
Douglas Gregorc15cb382009-02-09 23:23:08 +0000995 else if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
Anders Carlssone41590d2009-06-24 00:10:43 +0000996 return BuildDeclRefExpr(Template, Context.OverloadTy, Loc,
997 false, false, SS);
Anders Carlsson598da5b2009-08-29 01:06:32 +0000998 else if (UnresolvedUsingDecl *UD = dyn_cast<UnresolvedUsingDecl>(D))
Mike Stump1eb44332009-09-09 15:08:12 +0000999 return BuildDeclRefExpr(UD, Context.DependentTy, Loc,
1000 /*TypeDependent=*/true,
Anders Carlsson598da5b2009-08-29 01:06:32 +00001001 /*ValueDependent=*/true, SS);
1002
Steve Naroffdd972f22008-09-05 22:11:13 +00001003 ValueDecl *VD = cast<ValueDecl>(D);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001004
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001005 // Check whether this declaration can be used. Note that we suppress
1006 // this check when we're going to perform argument-dependent lookup
1007 // on this function name, because this might not be the function
1008 // that overload resolution actually selects.
Mike Stump1eb44332009-09-09 15:08:12 +00001009 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
Douglas Gregor751f9a42009-06-30 15:47:41 +00001010 HasTrailingLParen;
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001011 if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc))
1012 return ExprError();
1013
Steve Naroffdd972f22008-09-05 22:11:13 +00001014 // Only create DeclRefExpr's for valid Decl's.
1015 if (VD->isInvalidDecl())
Sebastian Redlcd965b92009-01-18 18:53:16 +00001016 return ExprError();
1017
Chris Lattner639e2d32008-10-20 05:16:36 +00001018 // If the identifier reference is inside a block, and it refers to a value
1019 // that is outside the block, create a BlockDeclRefExpr instead of a
1020 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when
1021 // the block is formed.
Steve Naroffdd972f22008-09-05 22:11:13 +00001022 //
Chris Lattner639e2d32008-10-20 05:16:36 +00001023 // We do not do this for things like enum constants, global variables, etc,
1024 // as they do not get snapshotted.
1025 //
1026 if (CurBlock && ShouldSnapshotBlockValueReference(CurBlock, VD)) {
Douglas Gregore0762c92009-06-19 23:52:42 +00001027 MarkDeclarationReferenced(Loc, VD);
Eli Friedman5fdeae12009-03-22 23:00:19 +00001028 QualType ExprTy = VD->getType().getNonReferenceType();
Steve Naroff090276f2008-10-10 01:28:17 +00001029 // The BlocksAttr indicates the variable is bound by-reference.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001030 if (VD->getAttr<BlocksAttr>())
Eli Friedman5fdeae12009-03-22 23:00:19 +00001031 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, true));
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +00001032 // This is to record that a 'const' was actually synthesize and added.
1033 bool constAdded = !ExprTy.isConstQualified();
Steve Naroff090276f2008-10-10 01:28:17 +00001034 // Variable will be bound by-copy, make it const within the closure.
Mike Stump1eb44332009-09-09 15:08:12 +00001035
Eli Friedman5fdeae12009-03-22 23:00:19 +00001036 ExprTy.addConst();
Mike Stump1eb44332009-09-09 15:08:12 +00001037 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, false,
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +00001038 constAdded));
Steve Naroff090276f2008-10-10 01:28:17 +00001039 }
1040 // If this reference is not in a block or if the referenced variable is
1041 // within the block, create a normal DeclRefExpr.
Douglas Gregor898574e2008-12-05 23:32:09 +00001042
Douglas Gregor898574e2008-12-05 23:32:09 +00001043 bool TypeDependent = false;
Douglas Gregor83f96f62008-12-10 20:57:37 +00001044 bool ValueDependent = false;
1045 if (getLangOptions().CPlusPlus) {
1046 // C++ [temp.dep.expr]p3:
Mike Stump1eb44332009-09-09 15:08:12 +00001047 // An id-expression is type-dependent if it contains:
Douglas Gregor83f96f62008-12-10 20:57:37 +00001048 // - an identifier that was declared with a dependent type,
1049 if (VD->getType()->isDependentType())
1050 TypeDependent = true;
1051 // - FIXME: a template-id that is dependent,
1052 // - a conversion-function-id that specifies a dependent type,
1053 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1054 Name.getCXXNameType()->isDependentType())
1055 TypeDependent = true;
1056 // - a nested-name-specifier that contains a class-name that
1057 // names a dependent type.
1058 else if (SS && !SS->isEmpty()) {
Douglas Gregore4e5b052009-03-19 00:18:19 +00001059 for (DeclContext *DC = computeDeclContext(*SS);
Douglas Gregor83f96f62008-12-10 20:57:37 +00001060 DC; DC = DC->getParent()) {
1061 // FIXME: could stop early at namespace scope.
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001062 if (DC->isRecord()) {
Douglas Gregor83f96f62008-12-10 20:57:37 +00001063 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1064 if (Context.getTypeDeclType(Record)->isDependentType()) {
1065 TypeDependent = true;
1066 break;
1067 }
Douglas Gregor898574e2008-12-05 23:32:09 +00001068 }
1069 }
1070 }
Douglas Gregor898574e2008-12-05 23:32:09 +00001071
Douglas Gregor83f96f62008-12-10 20:57:37 +00001072 // C++ [temp.dep.constexpr]p2:
1073 //
1074 // An identifier is value-dependent if it is:
1075 // - a name declared with a dependent type,
1076 if (TypeDependent)
1077 ValueDependent = true;
1078 // - the name of a non-type template parameter,
1079 else if (isa<NonTypeTemplateParmDecl>(VD))
1080 ValueDependent = true;
1081 // - a constant with integral or enumeration type and is
1082 // initialized with an expression that is value-dependent
Eli Friedmanc1494122009-06-11 01:11:20 +00001083 else if (const VarDecl *Dcl = dyn_cast<VarDecl>(VD)) {
John McCall0953e762009-09-24 19:53:00 +00001084 if (Dcl->getType().getCVRQualifiers() == Qualifiers::Const &&
Eli Friedmanc1494122009-06-11 01:11:20 +00001085 Dcl->getInit()) {
1086 ValueDependent = Dcl->getInit()->isValueDependent();
1087 }
1088 }
Douglas Gregor83f96f62008-12-10 20:57:37 +00001089 }
Douglas Gregor898574e2008-12-05 23:32:09 +00001090
Anders Carlssone41590d2009-06-24 00:10:43 +00001091 return BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), Loc,
1092 TypeDependent, ValueDependent, SS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001093}
1094
Sebastian Redlcd965b92009-01-18 18:53:16 +00001095Sema::OwningExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
1096 tok::TokenKind Kind) {
Chris Lattnerd9f69102008-08-10 01:53:14 +00001097 PredefinedExpr::IdentType IT;
Sebastian Redlcd965b92009-01-18 18:53:16 +00001098
Reid Spencer5f016e22007-07-11 17:01:13 +00001099 switch (Kind) {
Chris Lattner1423ea42008-01-12 18:39:25 +00001100 default: assert(0 && "Unknown simple primary expr!");
Chris Lattnerd9f69102008-08-10 01:53:14 +00001101 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
1102 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
1103 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00001104 }
Chris Lattner1423ea42008-01-12 18:39:25 +00001105
Chris Lattnerfa28b302008-01-12 08:14:25 +00001106 // Pre-defined identifiers are of type char[x], where x is the length of the
1107 // string.
Mike Stump1eb44332009-09-09 15:08:12 +00001108
Anders Carlsson3a082d82009-09-08 18:24:21 +00001109 Decl *currentDecl = getCurFunctionOrMethodDecl();
1110 if (!currentDecl) {
Chris Lattnerb0da9232008-12-12 05:05:20 +00001111 Diag(Loc, diag::ext_predef_outside_function);
Anders Carlsson3a082d82009-09-08 18:24:21 +00001112 currentDecl = Context.getTranslationUnitDecl();
Chris Lattnerb0da9232008-12-12 05:05:20 +00001113 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001114
Anders Carlsson773f3972009-09-11 01:22:35 +00001115 QualType ResTy;
1116 if (cast<DeclContext>(currentDecl)->isDependentContext()) {
1117 ResTy = Context.DependentTy;
1118 } else {
1119 unsigned Length =
1120 PredefinedExpr::ComputeName(Context, IT, currentDecl).length();
Sebastian Redlcd965b92009-01-18 18:53:16 +00001121
Anders Carlsson773f3972009-09-11 01:22:35 +00001122 llvm::APInt LengthI(32, Length + 1);
John McCall0953e762009-09-24 19:53:00 +00001123 ResTy = Context.CharTy.withConst();
Anders Carlsson773f3972009-09-11 01:22:35 +00001124 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
1125 }
Steve Naroff6ece14c2009-01-21 00:14:39 +00001126 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
Reid Spencer5f016e22007-07-11 17:01:13 +00001127}
1128
Sebastian Redlcd965b92009-01-18 18:53:16 +00001129Sema::OwningExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001130 llvm::SmallString<16> CharBuffer;
1131 CharBuffer.resize(Tok.getLength());
1132 const char *ThisTokBegin = &CharBuffer[0];
1133 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001134
Reid Spencer5f016e22007-07-11 17:01:13 +00001135 CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1136 Tok.getLocation(), PP);
1137 if (Literal.hadError())
Sebastian Redlcd965b92009-01-18 18:53:16 +00001138 return ExprError();
Chris Lattnerfc62bfd2008-03-01 08:32:21 +00001139
1140 QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy;
1141
Sebastian Redle91b3bc2009-01-20 22:23:13 +00001142 return Owned(new (Context) CharacterLiteral(Literal.getValue(),
1143 Literal.isWide(),
1144 type, Tok.getLocation()));
Reid Spencer5f016e22007-07-11 17:01:13 +00001145}
1146
Sebastian Redlcd965b92009-01-18 18:53:16 +00001147Action::OwningExprResult Sema::ActOnNumericConstant(const Token &Tok) {
1148 // Fast path for a single digit (which is quite common). A single digit
Reid Spencer5f016e22007-07-11 17:01:13 +00001149 // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
1150 if (Tok.getLength() == 1) {
Chris Lattner7216dc92009-01-26 22:36:52 +00001151 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
Chris Lattner0c21e842009-01-16 07:10:29 +00001152 unsigned IntSize = Context.Target.getIntWidth();
Steve Naroff6ece14c2009-01-21 00:14:39 +00001153 return Owned(new (Context) IntegerLiteral(llvm::APInt(IntSize, Val-'0'),
Steve Naroff0a473932009-01-20 19:53:53 +00001154 Context.IntTy, Tok.getLocation()));
Reid Spencer5f016e22007-07-11 17:01:13 +00001155 }
Ted Kremenek28396602009-01-13 23:19:12 +00001156
Reid Spencer5f016e22007-07-11 17:01:13 +00001157 llvm::SmallString<512> IntegerBuffer;
Chris Lattner2a299042008-09-30 20:53:45 +00001158 // Add padding so that NumericLiteralParser can overread by one character.
1159 IntegerBuffer.resize(Tok.getLength()+1);
Reid Spencer5f016e22007-07-11 17:01:13 +00001160 const char *ThisTokBegin = &IntegerBuffer[0];
Sebastian Redlcd965b92009-01-18 18:53:16 +00001161
Reid Spencer5f016e22007-07-11 17:01:13 +00001162 // Get the spelling of the token, which eliminates trigraphs, etc.
1163 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001164
Mike Stump1eb44332009-09-09 15:08:12 +00001165 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
Reid Spencer5f016e22007-07-11 17:01:13 +00001166 Tok.getLocation(), PP);
1167 if (Literal.hadError)
Sebastian Redlcd965b92009-01-18 18:53:16 +00001168 return ExprError();
1169
Chris Lattner5d661452007-08-26 03:42:43 +00001170 Expr *Res;
Sebastian Redlcd965b92009-01-18 18:53:16 +00001171
Chris Lattner5d661452007-08-26 03:42:43 +00001172 if (Literal.isFloatingLiteral()) {
Chris Lattner525a0502007-09-22 18:29:59 +00001173 QualType Ty;
Chris Lattnerb7cfe882008-06-30 18:32:54 +00001174 if (Literal.isFloat)
Chris Lattner525a0502007-09-22 18:29:59 +00001175 Ty = Context.FloatTy;
Chris Lattnerb7cfe882008-06-30 18:32:54 +00001176 else if (!Literal.isLong)
Chris Lattner525a0502007-09-22 18:29:59 +00001177 Ty = Context.DoubleTy;
Chris Lattnerb7cfe882008-06-30 18:32:54 +00001178 else
Chris Lattner9e9b6dc2008-03-08 08:52:55 +00001179 Ty = Context.LongDoubleTy;
Chris Lattnerb7cfe882008-06-30 18:32:54 +00001180
1181 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
1182
Ted Kremenek720c4ec2007-11-29 00:56:49 +00001183 // isExact will be set by GetFloatValue().
1184 bool isExact = false;
Chris Lattner001d64d2009-06-29 17:34:55 +00001185 llvm::APFloat Val = Literal.GetFloatValue(Format, &isExact);
1186 Res = new (Context) FloatingLiteral(Val, isExact, Ty, Tok.getLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001187
Chris Lattner5d661452007-08-26 03:42:43 +00001188 } else if (!Literal.isIntegerLiteral()) {
Sebastian Redlcd965b92009-01-18 18:53:16 +00001189 return ExprError();
Chris Lattner5d661452007-08-26 03:42:43 +00001190 } else {
Chris Lattnerf0467b32008-04-02 04:24:33 +00001191 QualType Ty;
Reid Spencer5f016e22007-07-11 17:01:13 +00001192
Neil Boothb9449512007-08-29 22:00:19 +00001193 // long long is a C99 feature.
1194 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
Neil Booth79859c32007-08-29 22:13:52 +00001195 Literal.isLongLong)
Neil Boothb9449512007-08-29 22:00:19 +00001196 Diag(Tok.getLocation(), diag::ext_longlong);
1197
Reid Spencer5f016e22007-07-11 17:01:13 +00001198 // Get the value in the widest-possible width.
Chris Lattner98be4942008-03-05 18:54:05 +00001199 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001200
Reid Spencer5f016e22007-07-11 17:01:13 +00001201 if (Literal.GetIntegerValue(ResultVal)) {
1202 // If this value didn't fit into uintmax_t, warn and force to ull.
1203 Diag(Tok.getLocation(), diag::warn_integer_too_large);
Chris Lattnerf0467b32008-04-02 04:24:33 +00001204 Ty = Context.UnsignedLongLongTy;
1205 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
Chris Lattner98be4942008-03-05 18:54:05 +00001206 "long long is not intmax_t?");
Reid Spencer5f016e22007-07-11 17:01:13 +00001207 } else {
1208 // If this value fits into a ULL, try to figure out what else it fits into
1209 // according to the rules of C99 6.4.4.1p5.
Sebastian Redlcd965b92009-01-18 18:53:16 +00001210
Reid Spencer5f016e22007-07-11 17:01:13 +00001211 // Octal, Hexadecimal, and integers with a U suffix are allowed to
1212 // be an unsigned int.
1213 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
1214
1215 // Check from smallest to largest, picking the smallest type we can.
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001216 unsigned Width = 0;
Chris Lattner97c51562007-08-23 21:58:08 +00001217 if (!Literal.isLong && !Literal.isLongLong) {
1218 // Are int/unsigned possibilities?
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001219 unsigned IntSize = Context.Target.getIntWidth();
Sebastian Redlcd965b92009-01-18 18:53:16 +00001220
Reid Spencer5f016e22007-07-11 17:01:13 +00001221 // Does it fit in a unsigned int?
1222 if (ResultVal.isIntN(IntSize)) {
1223 // Does it fit in a signed int?
1224 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001225 Ty = Context.IntTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00001226 else if (AllowUnsigned)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001227 Ty = Context.UnsignedIntTy;
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001228 Width = IntSize;
Reid Spencer5f016e22007-07-11 17:01:13 +00001229 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001230 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001231
Reid Spencer5f016e22007-07-11 17:01:13 +00001232 // Are long/unsigned long possibilities?
Chris Lattnerf0467b32008-04-02 04:24:33 +00001233 if (Ty.isNull() && !Literal.isLongLong) {
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001234 unsigned LongSize = Context.Target.getLongWidth();
Sebastian Redlcd965b92009-01-18 18:53:16 +00001235
Reid Spencer5f016e22007-07-11 17:01:13 +00001236 // Does it fit in a unsigned long?
1237 if (ResultVal.isIntN(LongSize)) {
1238 // Does it fit in a signed long?
1239 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001240 Ty = Context.LongTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00001241 else if (AllowUnsigned)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001242 Ty = Context.UnsignedLongTy;
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001243 Width = LongSize;
Reid Spencer5f016e22007-07-11 17:01:13 +00001244 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001245 }
1246
Reid Spencer5f016e22007-07-11 17:01:13 +00001247 // Finally, check long long if needed.
Chris Lattnerf0467b32008-04-02 04:24:33 +00001248 if (Ty.isNull()) {
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001249 unsigned LongLongSize = Context.Target.getLongLongWidth();
Sebastian Redlcd965b92009-01-18 18:53:16 +00001250
Reid Spencer5f016e22007-07-11 17:01:13 +00001251 // Does it fit in a unsigned long long?
1252 if (ResultVal.isIntN(LongLongSize)) {
1253 // Does it fit in a signed long long?
1254 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001255 Ty = Context.LongLongTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00001256 else if (AllowUnsigned)
Chris Lattnerf0467b32008-04-02 04:24:33 +00001257 Ty = Context.UnsignedLongLongTy;
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001258 Width = LongLongSize;
Reid Spencer5f016e22007-07-11 17:01:13 +00001259 }
1260 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001261
Reid Spencer5f016e22007-07-11 17:01:13 +00001262 // If we still couldn't decide a type, we probably have something that
1263 // does not fit in a signed long long, but has no U suffix.
Chris Lattnerf0467b32008-04-02 04:24:33 +00001264 if (Ty.isNull()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001265 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
Chris Lattnerf0467b32008-04-02 04:24:33 +00001266 Ty = Context.UnsignedLongLongTy;
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001267 Width = Context.Target.getLongLongWidth();
Reid Spencer5f016e22007-07-11 17:01:13 +00001268 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001269
Chris Lattner8cbcb0e2008-05-09 05:59:00 +00001270 if (ResultVal.getBitWidth() != Width)
1271 ResultVal.trunc(Width);
Reid Spencer5f016e22007-07-11 17:01:13 +00001272 }
Sebastian Redle91b3bc2009-01-20 22:23:13 +00001273 Res = new (Context) IntegerLiteral(ResultVal, Ty, Tok.getLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00001274 }
Sebastian Redlcd965b92009-01-18 18:53:16 +00001275
Chris Lattner5d661452007-08-26 03:42:43 +00001276 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
1277 if (Literal.isImaginary)
Mike Stump1eb44332009-09-09 15:08:12 +00001278 Res = new (Context) ImaginaryLiteral(Res,
Steve Naroff6ece14c2009-01-21 00:14:39 +00001279 Context.getComplexType(Res->getType()));
Sebastian Redlcd965b92009-01-18 18:53:16 +00001280
1281 return Owned(Res);
Reid Spencer5f016e22007-07-11 17:01:13 +00001282}
1283
Sebastian Redlcd965b92009-01-18 18:53:16 +00001284Action::OwningExprResult Sema::ActOnParenExpr(SourceLocation L,
1285 SourceLocation R, ExprArg Val) {
Anders Carlssone9146f22009-05-01 19:49:17 +00001286 Expr *E = Val.takeAs<Expr>();
Chris Lattnerf0467b32008-04-02 04:24:33 +00001287 assert((E != 0) && "ActOnParenExpr() missing expr");
Steve Naroff6ece14c2009-01-21 00:14:39 +00001288 return Owned(new (Context) ParenExpr(L, R, E));
Reid Spencer5f016e22007-07-11 17:01:13 +00001289}
1290
1291/// The UsualUnaryConversions() function is *not* called by this routine.
1292/// See C99 6.3.2.1p[2-4] for more details.
Sebastian Redl28507842009-02-26 14:39:58 +00001293bool Sema::CheckSizeOfAlignOfOperand(QualType exprType,
Sebastian Redl05189992008-11-11 17:56:53 +00001294 SourceLocation OpLoc,
1295 const SourceRange &ExprRange,
1296 bool isSizeof) {
Sebastian Redl28507842009-02-26 14:39:58 +00001297 if (exprType->isDependentType())
1298 return false;
1299
Reid Spencer5f016e22007-07-11 17:01:13 +00001300 // C99 6.5.3.4p1:
Chris Lattner01072922009-01-24 19:46:37 +00001301 if (isa<FunctionType>(exprType)) {
Chris Lattner1efaa952009-04-24 00:30:45 +00001302 // alignof(function) is allowed as an extension.
Chris Lattner01072922009-01-24 19:46:37 +00001303 if (isSizeof)
1304 Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange;
1305 return false;
1306 }
Mike Stump1eb44332009-09-09 15:08:12 +00001307
Chris Lattner1efaa952009-04-24 00:30:45 +00001308 // Allow sizeof(void)/alignof(void) as an extension.
Chris Lattner01072922009-01-24 19:46:37 +00001309 if (exprType->isVoidType()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001310 Diag(OpLoc, diag::ext_sizeof_void_type)
1311 << (isSizeof ? "sizeof" : "__alignof") << ExprRange;
Chris Lattner01072922009-01-24 19:46:37 +00001312 return false;
1313 }
Mike Stump1eb44332009-09-09 15:08:12 +00001314
Chris Lattner1efaa952009-04-24 00:30:45 +00001315 if (RequireCompleteType(OpLoc, exprType,
Mike Stump1eb44332009-09-09 15:08:12 +00001316 isSizeof ? diag::err_sizeof_incomplete_type :
Anders Carlssonb7906612009-08-26 23:45:07 +00001317 PDiag(diag::err_alignof_incomplete_type)
1318 << ExprRange))
Chris Lattner1efaa952009-04-24 00:30:45 +00001319 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001320
Chris Lattner1efaa952009-04-24 00:30:45 +00001321 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode.
Fariborz Jahanianced1e282009-04-24 17:34:33 +00001322 if (LangOpts.ObjCNonFragileABI && exprType->isObjCInterfaceType()) {
Chris Lattner1efaa952009-04-24 00:30:45 +00001323 Diag(OpLoc, diag::err_sizeof_nonfragile_interface)
Chris Lattner5cb10d32009-04-24 22:30:50 +00001324 << exprType << isSizeof << ExprRange;
1325 return true;
Chris Lattnerca790922009-04-21 19:55:16 +00001326 }
Mike Stump1eb44332009-09-09 15:08:12 +00001327
Chris Lattner1efaa952009-04-24 00:30:45 +00001328 return false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001329}
1330
Chris Lattner31e21e02009-01-24 20:17:12 +00001331bool Sema::CheckAlignOfExpr(Expr *E, SourceLocation OpLoc,
1332 const SourceRange &ExprRange) {
1333 E = E->IgnoreParens();
Sebastian Redl28507842009-02-26 14:39:58 +00001334
Mike Stump1eb44332009-09-09 15:08:12 +00001335 // alignof decl is always ok.
Chris Lattner31e21e02009-01-24 20:17:12 +00001336 if (isa<DeclRefExpr>(E))
1337 return false;
Sebastian Redl28507842009-02-26 14:39:58 +00001338
1339 // Cannot know anything else if the expression is dependent.
1340 if (E->isTypeDependent())
1341 return false;
1342
Douglas Gregor33bbbc52009-05-02 02:18:30 +00001343 if (E->getBitField()) {
1344 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange;
1345 return true;
Chris Lattner31e21e02009-01-24 20:17:12 +00001346 }
Douglas Gregor33bbbc52009-05-02 02:18:30 +00001347
1348 // Alignment of a field access is always okay, so long as it isn't a
1349 // bit-field.
1350 if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
Mike Stump8e1fab22009-07-22 18:58:19 +00001351 if (isa<FieldDecl>(ME->getMemberDecl()))
Douglas Gregor33bbbc52009-05-02 02:18:30 +00001352 return false;
1353
Chris Lattner31e21e02009-01-24 20:17:12 +00001354 return CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false);
1355}
1356
Douglas Gregorba498172009-03-13 21:01:28 +00001357/// \brief Build a sizeof or alignof expression given a type operand.
Mike Stump1eb44332009-09-09 15:08:12 +00001358Action::OwningExprResult
1359Sema::CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001360 bool isSizeOf, SourceRange R) {
1361 if (T.isNull())
1362 return ExprError();
1363
1364 if (!T->isDependentType() &&
1365 CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf))
1366 return ExprError();
1367
1368 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1369 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, T,
1370 Context.getSizeType(), OpLoc,
1371 R.getEnd()));
1372}
1373
1374/// \brief Build a sizeof or alignof expression given an expression
1375/// operand.
Mike Stump1eb44332009-09-09 15:08:12 +00001376Action::OwningExprResult
1377Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001378 bool isSizeOf, SourceRange R) {
1379 // Verify that the operand is valid.
1380 bool isInvalid = false;
1381 if (E->isTypeDependent()) {
1382 // Delay type-checking for type-dependent expressions.
1383 } else if (!isSizeOf) {
1384 isInvalid = CheckAlignOfExpr(E, OpLoc, R);
Douglas Gregor33bbbc52009-05-02 02:18:30 +00001385 } else if (E->getBitField()) { // C99 6.5.3.4p1.
Douglas Gregorba498172009-03-13 21:01:28 +00001386 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0;
1387 isInvalid = true;
1388 } else {
1389 isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true);
1390 }
1391
1392 if (isInvalid)
1393 return ExprError();
1394
1395 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1396 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E,
1397 Context.getSizeType(), OpLoc,
1398 R.getEnd()));
1399}
1400
Sebastian Redl05189992008-11-11 17:56:53 +00001401/// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and
1402/// the same for @c alignof and @c __alignof
1403/// Note that the ArgRange is invalid if isType is false.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001404Action::OwningExprResult
Sebastian Redl05189992008-11-11 17:56:53 +00001405Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1406 void *TyOrEx, const SourceRange &ArgRange) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001407 // If error parsing type, ignore.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001408 if (TyOrEx == 0) return ExprError();
Reid Spencer5f016e22007-07-11 17:01:13 +00001409
Sebastian Redl05189992008-11-11 17:56:53 +00001410 if (isType) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00001411 // FIXME: Preserve type source info.
1412 QualType ArgTy = GetTypeFromParser(TyOrEx);
Douglas Gregorba498172009-03-13 21:01:28 +00001413 return CreateSizeOfAlignOfExpr(ArgTy, OpLoc, isSizeof, ArgRange);
Mike Stump1eb44332009-09-09 15:08:12 +00001414 }
Sebastian Redl05189992008-11-11 17:56:53 +00001415
Douglas Gregorba498172009-03-13 21:01:28 +00001416 // Get the end location.
1417 Expr *ArgEx = (Expr *)TyOrEx;
1418 Action::OwningExprResult Result
1419 = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange());
1420
1421 if (Result.isInvalid())
1422 DeleteExpr(ArgEx);
1423
1424 return move(Result);
Reid Spencer5f016e22007-07-11 17:01:13 +00001425}
1426
Chris Lattnerba27e2a2009-02-17 08:12:06 +00001427QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc, bool isReal) {
Sebastian Redl28507842009-02-26 14:39:58 +00001428 if (V->isTypeDependent())
1429 return Context.DependentTy;
Mike Stump1eb44332009-09-09 15:08:12 +00001430
Chris Lattnercc26ed72007-08-26 05:39:26 +00001431 // These operators return the element type of a complex type.
John McCall183700f2009-09-21 23:43:11 +00001432 if (const ComplexType *CT = V->getType()->getAs<ComplexType>())
Chris Lattnerdbb36972007-08-24 21:16:53 +00001433 return CT->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +00001434
Chris Lattnercc26ed72007-08-26 05:39:26 +00001435 // Otherwise they pass through real integer and floating point types here.
1436 if (V->getType()->isArithmeticType())
1437 return V->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001438
Chris Lattnercc26ed72007-08-26 05:39:26 +00001439 // Reject anything else.
Chris Lattnerba27e2a2009-02-17 08:12:06 +00001440 Diag(Loc, diag::err_realimag_invalid_type) << V->getType()
1441 << (isReal ? "__real" : "__imag");
Chris Lattnercc26ed72007-08-26 05:39:26 +00001442 return QualType();
Chris Lattnerdbb36972007-08-24 21:16:53 +00001443}
1444
1445
Reid Spencer5f016e22007-07-11 17:01:13 +00001446
Sebastian Redl0eb23302009-01-19 00:08:26 +00001447Action::OwningExprResult
1448Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1449 tok::TokenKind Kind, ExprArg Input) {
Nate Begeman2ef13e52009-08-10 23:49:36 +00001450 // Since this might be a postfix expression, get rid of ParenListExprs.
1451 Input = MaybeConvertParenListExprToParenExpr(S, move(Input));
Sebastian Redl0eb23302009-01-19 00:08:26 +00001452 Expr *Arg = (Expr *)Input.get();
Douglas Gregor74253732008-11-19 15:42:04 +00001453
Reid Spencer5f016e22007-07-11 17:01:13 +00001454 UnaryOperator::Opcode Opc;
1455 switch (Kind) {
1456 default: assert(0 && "Unknown unary op!");
1457 case tok::plusplus: Opc = UnaryOperator::PostInc; break;
1458 case tok::minusminus: Opc = UnaryOperator::PostDec; break;
1459 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00001460
Douglas Gregor74253732008-11-19 15:42:04 +00001461 if (getLangOptions().CPlusPlus &&
1462 (Arg->getType()->isRecordType() || Arg->getType()->isEnumeralType())) {
1463 // Which overloaded operator?
Sebastian Redl0eb23302009-01-19 00:08:26 +00001464 OverloadedOperatorKind OverOp =
Douglas Gregor74253732008-11-19 15:42:04 +00001465 (Opc == UnaryOperator::PostInc)? OO_PlusPlus : OO_MinusMinus;
1466
1467 // C++ [over.inc]p1:
1468 //
1469 // [...] If the function is a member function with one
1470 // parameter (which shall be of type int) or a non-member
1471 // function with two parameters (the second of which shall be
1472 // of type int), it defines the postfix increment operator ++
1473 // for objects of that type. When the postfix increment is
1474 // called as a result of using the ++ operator, the int
1475 // argument will have value zero.
Mike Stump1eb44332009-09-09 15:08:12 +00001476 Expr *Args[2] = {
1477 Arg,
1478 new (Context) IntegerLiteral(llvm::APInt(Context.Target.getIntWidth(), 0,
Steve Naroff6ece14c2009-01-21 00:14:39 +00001479 /*isSigned=*/true), Context.IntTy, SourceLocation())
Douglas Gregor74253732008-11-19 15:42:04 +00001480 };
1481
1482 // Build the candidate set for overloading
1483 OverloadCandidateSet CandidateSet;
Douglas Gregor063daf62009-03-13 18:40:31 +00001484 AddOperatorCandidates(OverOp, S, OpLoc, Args, 2, CandidateSet);
Douglas Gregor74253732008-11-19 15:42:04 +00001485
1486 // Perform overload resolution.
1487 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00001488 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
Douglas Gregor74253732008-11-19 15:42:04 +00001489 case OR_Success: {
1490 // We found a built-in operator or an overloaded operator.
1491 FunctionDecl *FnDecl = Best->Function;
1492
1493 if (FnDecl) {
1494 // We matched an overloaded operator. Build a call to that
1495 // operator.
1496
1497 // Convert the arguments.
1498 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1499 if (PerformObjectArgumentInitialization(Arg, Method))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001500 return ExprError();
Douglas Gregor74253732008-11-19 15:42:04 +00001501 } else {
1502 // Convert the arguments.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001503 if (PerformCopyInitialization(Arg,
Douglas Gregor74253732008-11-19 15:42:04 +00001504 FnDecl->getParamDecl(0)->getType(),
1505 "passing"))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001506 return ExprError();
Douglas Gregor74253732008-11-19 15:42:04 +00001507 }
1508
1509 // Determine the result type
Anders Carlsson07d68f12009-10-13 21:49:31 +00001510 QualType ResultTy = FnDecl->getResultType().getNonReferenceType();
Sebastian Redl0eb23302009-01-19 00:08:26 +00001511
Douglas Gregor74253732008-11-19 15:42:04 +00001512 // Build the actual expression node.
Steve Naroff6ece14c2009-01-21 00:14:39 +00001513 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
Mike Stump488e25b2009-02-19 02:54:59 +00001514 SourceLocation());
Douglas Gregor74253732008-11-19 15:42:04 +00001515 UsualUnaryConversions(FnExpr);
1516
Sebastian Redl0eb23302009-01-19 00:08:26 +00001517 Input.release();
Douglas Gregor7ff69262009-05-27 05:00:47 +00001518 Args[0] = Arg;
Anders Carlsson07d68f12009-10-13 21:49:31 +00001519
1520 ExprOwningPtr<CXXOperatorCallExpr>
1521 TheCall(this, new (Context) CXXOperatorCallExpr(Context, OverOp,
1522 FnExpr, Args, 2,
1523 ResultTy, OpLoc));
1524
1525 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall.get(),
1526 FnDecl))
1527 return ExprError();
Anders Carlsson3a9439f2009-10-13 22:22:09 +00001528 return Owned(TheCall.release());
1529
Douglas Gregor74253732008-11-19 15:42:04 +00001530 } else {
1531 // We matched a built-in operator. Convert the arguments, then
1532 // break out so that we will build the appropriate built-in
1533 // operator node.
1534 if (PerformCopyInitialization(Arg, Best->BuiltinTypes.ParamTypes[0],
1535 "passing"))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001536 return ExprError();
Douglas Gregor74253732008-11-19 15:42:04 +00001537
1538 break;
Sebastian Redl0eb23302009-01-19 00:08:26 +00001539 }
Douglas Gregor74253732008-11-19 15:42:04 +00001540 }
1541
Douglas Gregor33074752009-09-30 21:46:01 +00001542 case OR_No_Viable_Function: {
1543 // No viable function; try checking this as a built-in operator, which
1544 // will fail and provide a diagnostic. Then, print the overload
1545 // candidates.
1546 OwningExprResult Result = CreateBuiltinUnaryOp(OpLoc, Opc, move(Input));
1547 assert(Result.isInvalid() &&
1548 "C++ postfix-unary operator overloading is missing candidates!");
1549 if (Result.isInvalid())
1550 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false);
1551
1552 return move(Result);
1553 }
1554
Douglas Gregor74253732008-11-19 15:42:04 +00001555 case OR_Ambiguous:
1556 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
1557 << UnaryOperator::getOpcodeStr(Opc)
1558 << Arg->getSourceRange();
1559 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001560 return ExprError();
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001561
1562 case OR_Deleted:
1563 Diag(OpLoc, diag::err_ovl_deleted_oper)
1564 << Best->Function->isDeleted()
1565 << UnaryOperator::getOpcodeStr(Opc)
1566 << Arg->getSourceRange();
1567 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1568 return ExprError();
Douglas Gregor74253732008-11-19 15:42:04 +00001569 }
1570
1571 // Either we found no viable overloaded operator or we matched a
1572 // built-in operator. In either case, fall through to trying to
1573 // build a built-in operation.
1574 }
1575
Eli Friedman6016cb22009-07-22 23:24:42 +00001576 Input.release();
1577 Input = Arg;
Eli Friedmande99a452009-07-22 22:25:00 +00001578 return CreateBuiltinUnaryOp(OpLoc, Opc, move(Input));
Reid Spencer5f016e22007-07-11 17:01:13 +00001579}
1580
Sebastian Redl0eb23302009-01-19 00:08:26 +00001581Action::OwningExprResult
1582Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc,
1583 ExprArg Idx, SourceLocation RLoc) {
Nate Begeman2ef13e52009-08-10 23:49:36 +00001584 // Since this might be a postfix expression, get rid of ParenListExprs.
1585 Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
1586
Sebastian Redl0eb23302009-01-19 00:08:26 +00001587 Expr *LHSExp = static_cast<Expr*>(Base.get()),
1588 *RHSExp = static_cast<Expr*>(Idx.get());
Mike Stump1eb44332009-09-09 15:08:12 +00001589
Douglas Gregor337c6b92008-11-19 17:17:41 +00001590 if (getLangOptions().CPlusPlus &&
Douglas Gregor3384c9c2009-05-19 00:01:19 +00001591 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) {
1592 Base.release();
1593 Idx.release();
1594 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1595 Context.DependentTy, RLoc));
1596 }
1597
Mike Stump1eb44332009-09-09 15:08:12 +00001598 if (getLangOptions().CPlusPlus &&
Sebastian Redl0eb23302009-01-19 00:08:26 +00001599 (LHSExp->getType()->isRecordType() ||
Eli Friedman03f332a2008-12-15 22:34:21 +00001600 LHSExp->getType()->isEnumeralType() ||
1601 RHSExp->getType()->isRecordType() ||
1602 RHSExp->getType()->isEnumeralType())) {
Mike Stump1eb44332009-09-09 15:08:12 +00001603 // Add the appropriate overloaded operators (C++ [over.match.oper])
Douglas Gregor337c6b92008-11-19 17:17:41 +00001604 // to the candidate set.
1605 OverloadCandidateSet CandidateSet;
1606 Expr *Args[2] = { LHSExp, RHSExp };
Douglas Gregor063daf62009-03-13 18:40:31 +00001607 AddOperatorCandidates(OO_Subscript, S, LLoc, Args, 2, CandidateSet,
1608 SourceRange(LLoc, RLoc));
Sebastian Redl0eb23302009-01-19 00:08:26 +00001609
Douglas Gregor337c6b92008-11-19 17:17:41 +00001610 // Perform overload resolution.
1611 OverloadCandidateSet::iterator Best;
Douglas Gregore0762c92009-06-19 23:52:42 +00001612 switch (BestViableFunction(CandidateSet, LLoc, Best)) {
Douglas Gregor337c6b92008-11-19 17:17:41 +00001613 case OR_Success: {
1614 // We found a built-in operator or an overloaded operator.
1615 FunctionDecl *FnDecl = Best->Function;
1616
1617 if (FnDecl) {
1618 // We matched an overloaded operator. Build a call to that
1619 // operator.
1620
1621 // Convert the arguments.
1622 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1623 if (PerformObjectArgumentInitialization(LHSExp, Method) ||
Mike Stump1eb44332009-09-09 15:08:12 +00001624 PerformCopyInitialization(RHSExp,
Douglas Gregor337c6b92008-11-19 17:17:41 +00001625 FnDecl->getParamDecl(0)->getType(),
1626 "passing"))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001627 return ExprError();
Douglas Gregor337c6b92008-11-19 17:17:41 +00001628 } else {
1629 // Convert the arguments.
1630 if (PerformCopyInitialization(LHSExp,
1631 FnDecl->getParamDecl(0)->getType(),
1632 "passing") ||
1633 PerformCopyInitialization(RHSExp,
1634 FnDecl->getParamDecl(1)->getType(),
1635 "passing"))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001636 return ExprError();
Douglas Gregor337c6b92008-11-19 17:17:41 +00001637 }
1638
1639 // Determine the result type
Anders Carlsson3a9439f2009-10-13 22:22:09 +00001640 QualType ResultTy = FnDecl->getResultType().getNonReferenceType();
Sebastian Redl0eb23302009-01-19 00:08:26 +00001641
Douglas Gregor337c6b92008-11-19 17:17:41 +00001642 // Build the actual expression node.
Mike Stumpeed9cac2009-02-19 03:04:26 +00001643 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1644 SourceLocation());
Douglas Gregor337c6b92008-11-19 17:17:41 +00001645 UsualUnaryConversions(FnExpr);
1646
Sebastian Redl0eb23302009-01-19 00:08:26 +00001647 Base.release();
1648 Idx.release();
Douglas Gregor7ff69262009-05-27 05:00:47 +00001649 Args[0] = LHSExp;
1650 Args[1] = RHSExp;
Anders Carlsson3a9439f2009-10-13 22:22:09 +00001651
1652 ExprOwningPtr<CXXOperatorCallExpr>
1653 TheCall(this, new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
1654 FnExpr, Args, 2,
1655 ResultTy, RLoc));
1656 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall.get(),
1657 FnDecl))
1658 return ExprError();
1659
1660 return Owned(TheCall.release());
Douglas Gregor337c6b92008-11-19 17:17:41 +00001661 } else {
1662 // We matched a built-in operator. Convert the arguments, then
1663 // break out so that we will build the appropriate built-in
1664 // operator node.
1665 if (PerformCopyInitialization(LHSExp, Best->BuiltinTypes.ParamTypes[0],
1666 "passing") ||
1667 PerformCopyInitialization(RHSExp, Best->BuiltinTypes.ParamTypes[1],
1668 "passing"))
Sebastian Redl0eb23302009-01-19 00:08:26 +00001669 return ExprError();
Douglas Gregor337c6b92008-11-19 17:17:41 +00001670
1671 break;
1672 }
1673 }
1674
1675 case OR_No_Viable_Function:
1676 // No viable function; fall through to handling this as a
1677 // built-in operator, which will produce an error message for us.
1678 break;
1679
1680 case OR_Ambiguous:
1681 Diag(LLoc, diag::err_ovl_ambiguous_oper)
1682 << "[]"
1683 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1684 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001685 return ExprError();
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001686
1687 case OR_Deleted:
1688 Diag(LLoc, diag::err_ovl_deleted_oper)
1689 << Best->Function->isDeleted()
1690 << "[]"
1691 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1692 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1693 return ExprError();
Douglas Gregor337c6b92008-11-19 17:17:41 +00001694 }
1695
1696 // Either we found no viable overloaded operator or we matched a
1697 // built-in operator. In either case, fall through to trying to
1698 // build a built-in operation.
1699 }
1700
Chris Lattner12d9ff62007-07-16 00:14:47 +00001701 // Perform default conversions.
1702 DefaultFunctionArrayConversion(LHSExp);
1703 DefaultFunctionArrayConversion(RHSExp);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001704
Chris Lattner12d9ff62007-07-16 00:14:47 +00001705 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
Reid Spencer5f016e22007-07-11 17:01:13 +00001706
Reid Spencer5f016e22007-07-11 17:01:13 +00001707 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001708 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
Mike Stumpeed9cac2009-02-19 03:04:26 +00001709 // in the subscript position. As a result, we need to derive the array base
Reid Spencer5f016e22007-07-11 17:01:13 +00001710 // and index from the expression types.
Chris Lattner12d9ff62007-07-16 00:14:47 +00001711 Expr *BaseExpr, *IndexExpr;
1712 QualType ResultType;
Sebastian Redl28507842009-02-26 14:39:58 +00001713 if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
1714 BaseExpr = LHSExp;
1715 IndexExpr = RHSExp;
1716 ResultType = Context.DependentTy;
Ted Kremenek6217b802009-07-29 21:53:49 +00001717 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
Chris Lattner12d9ff62007-07-16 00:14:47 +00001718 BaseExpr = LHSExp;
1719 IndexExpr = RHSExp;
Chris Lattner12d9ff62007-07-16 00:14:47 +00001720 ResultType = PTy->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +00001721 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
Chris Lattner7a2e0472007-07-16 00:23:25 +00001722 // Handle the uncommon case of "123[Ptr]".
Chris Lattner12d9ff62007-07-16 00:14:47 +00001723 BaseExpr = RHSExp;
1724 IndexExpr = LHSExp;
Chris Lattner12d9ff62007-07-16 00:14:47 +00001725 ResultType = PTy->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +00001726 } else if (const ObjCObjectPointerType *PTy =
John McCall183700f2009-09-21 23:43:11 +00001727 LHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff14108da2009-07-10 23:34:53 +00001728 BaseExpr = LHSExp;
1729 IndexExpr = RHSExp;
1730 ResultType = PTy->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +00001731 } else if (const ObjCObjectPointerType *PTy =
John McCall183700f2009-09-21 23:43:11 +00001732 RHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff14108da2009-07-10 23:34:53 +00001733 // Handle the uncommon case of "123[Ptr]".
1734 BaseExpr = RHSExp;
1735 IndexExpr = LHSExp;
1736 ResultType = PTy->getPointeeType();
John McCall183700f2009-09-21 23:43:11 +00001737 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
Chris Lattnerc8629632007-07-31 19:29:30 +00001738 BaseExpr = LHSExp; // vectors: V[123]
Chris Lattner12d9ff62007-07-16 00:14:47 +00001739 IndexExpr = RHSExp;
Nate Begeman334a8022009-01-18 00:45:31 +00001740
Chris Lattner12d9ff62007-07-16 00:14:47 +00001741 // FIXME: need to deal with const...
1742 ResultType = VTy->getElementType();
Eli Friedman7c32f8e2009-04-25 23:46:54 +00001743 } else if (LHSTy->isArrayType()) {
1744 // If we see an array that wasn't promoted by
1745 // DefaultFunctionArrayConversion, it must be an array that
1746 // wasn't promoted because of the C90 rule that doesn't
1747 // allow promoting non-lvalue arrays. Warn, then
1748 // force the promotion here.
1749 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1750 LHSExp->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00001751 ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
1752 CastExpr::CK_ArrayToPointerDecay);
Eli Friedman7c32f8e2009-04-25 23:46:54 +00001753 LHSTy = LHSExp->getType();
1754
1755 BaseExpr = LHSExp;
1756 IndexExpr = RHSExp;
Ted Kremenek6217b802009-07-29 21:53:49 +00001757 ResultType = LHSTy->getAs<PointerType>()->getPointeeType();
Eli Friedman7c32f8e2009-04-25 23:46:54 +00001758 } else if (RHSTy->isArrayType()) {
1759 // Same as previous, except for 123[f().a] case
1760 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1761 RHSExp->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00001762 ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
1763 CastExpr::CK_ArrayToPointerDecay);
Eli Friedman7c32f8e2009-04-25 23:46:54 +00001764 RHSTy = RHSExp->getType();
1765
1766 BaseExpr = RHSExp;
1767 IndexExpr = LHSExp;
Ted Kremenek6217b802009-07-29 21:53:49 +00001768 ResultType = RHSTy->getAs<PointerType>()->getPointeeType();
Reid Spencer5f016e22007-07-11 17:01:13 +00001769 } else {
Chris Lattner338395d2009-04-25 22:50:55 +00001770 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
1771 << LHSExp->getSourceRange() << RHSExp->getSourceRange());
Sebastian Redl0eb23302009-01-19 00:08:26 +00001772 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001773 // C99 6.5.2.1p1
Nate Begeman2ef13e52009-08-10 23:49:36 +00001774 if (!(IndexExpr->getType()->isIntegerType() &&
1775 IndexExpr->getType()->isScalarType()) && !IndexExpr->isTypeDependent())
Chris Lattner338395d2009-04-25 22:50:55 +00001776 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
1777 << IndexExpr->getSourceRange());
Reid Spencer5f016e22007-07-11 17:01:13 +00001778
Daniel Dunbar7e88a602009-09-17 06:31:17 +00001779 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
Sam Weinig0f9a5b52009-09-14 20:14:57 +00001780 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
1781 && !IndexExpr->isTypeDependent())
Sam Weinig76e2b712009-09-14 01:58:58 +00001782 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();
1783
Douglas Gregore7450f52009-03-24 19:52:54 +00001784 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
Mike Stump1eb44332009-09-09 15:08:12 +00001785 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
1786 // type. Note that Functions are not objects, and that (in C99 parlance)
Douglas Gregore7450f52009-03-24 19:52:54 +00001787 // incomplete types are not object types.
1788 if (ResultType->isFunctionType()) {
1789 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
1790 << ResultType << BaseExpr->getSourceRange();
1791 return ExprError();
1792 }
Mike Stump1eb44332009-09-09 15:08:12 +00001793
Douglas Gregore7450f52009-03-24 19:52:54 +00001794 if (!ResultType->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00001795 RequireCompleteType(LLoc, ResultType,
Anders Carlssonb7906612009-08-26 23:45:07 +00001796 PDiag(diag::err_subscript_incomplete_type)
1797 << BaseExpr->getSourceRange()))
Douglas Gregore7450f52009-03-24 19:52:54 +00001798 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00001799
Chris Lattner1efaa952009-04-24 00:30:45 +00001800 // Diagnose bad cases where we step over interface counts.
1801 if (ResultType->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
1802 Diag(LLoc, diag::err_subscript_nonfragile_interface)
1803 << ResultType << BaseExpr->getSourceRange();
1804 return ExprError();
1805 }
Mike Stump1eb44332009-09-09 15:08:12 +00001806
Sebastian Redl0eb23302009-01-19 00:08:26 +00001807 Base.release();
1808 Idx.release();
Mike Stumpeed9cac2009-02-19 03:04:26 +00001809 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
Steve Naroff6ece14c2009-01-21 00:14:39 +00001810 ResultType, RLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +00001811}
1812
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001813QualType Sema::
Nate Begeman213541a2008-04-18 23:10:10 +00001814CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001815 const IdentifierInfo *CompName,
Anders Carlsson8f28f992009-08-26 18:25:21 +00001816 SourceLocation CompLoc) {
Daniel Dunbar2ad32892009-10-18 02:09:38 +00001817 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
1818 // see FIXME there.
1819 //
1820 // FIXME: This logic can be greatly simplified by splitting it along
1821 // halving/not halving and reworking the component checking.
John McCall183700f2009-09-21 23:43:11 +00001822 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
Nate Begeman8a997642008-05-09 06:41:27 +00001823
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001824 // The vector accessor can't exceed the number of elements.
Daniel Dunbare013d682009-10-18 20:26:12 +00001825 const char *compStr = CompName->getNameStart();
Nate Begeman353417a2009-01-18 01:47:54 +00001826
Mike Stumpeed9cac2009-02-19 03:04:26 +00001827 // This flag determines whether or not the component is one of the four
Nate Begeman353417a2009-01-18 01:47:54 +00001828 // special names that indicate a subset of exactly half the elements are
1829 // to be selected.
1830 bool HalvingSwizzle = false;
Mike Stumpeed9cac2009-02-19 03:04:26 +00001831
Nate Begeman353417a2009-01-18 01:47:54 +00001832 // This flag determines whether or not CompName has an 's' char prefix,
1833 // indicating that it is a string of hex values to be used as vector indices.
Nate Begeman131f4652009-06-25 21:06:09 +00001834 bool HexSwizzle = *compStr == 's' || *compStr == 'S';
Nate Begeman8a997642008-05-09 06:41:27 +00001835
1836 // Check that we've found one of the special components, or that the component
1837 // names must come from the same set.
Mike Stumpeed9cac2009-02-19 03:04:26 +00001838 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
Nate Begeman353417a2009-01-18 01:47:54 +00001839 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
1840 HalvingSwizzle = true;
Nate Begeman8a997642008-05-09 06:41:27 +00001841 } else if (vecType->getPointAccessorIdx(*compStr) != -1) {
Chris Lattner88dca042007-08-02 22:33:49 +00001842 do
1843 compStr++;
1844 while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1);
Nate Begeman353417a2009-01-18 01:47:54 +00001845 } else if (HexSwizzle || vecType->getNumericAccessorIdx(*compStr) != -1) {
Chris Lattner88dca042007-08-02 22:33:49 +00001846 do
1847 compStr++;
Nate Begeman353417a2009-01-18 01:47:54 +00001848 while (*compStr && vecType->getNumericAccessorIdx(*compStr) != -1);
Chris Lattner88dca042007-08-02 22:33:49 +00001849 }
Nate Begeman353417a2009-01-18 01:47:54 +00001850
Mike Stumpeed9cac2009-02-19 03:04:26 +00001851 if (!HalvingSwizzle && *compStr) {
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001852 // We didn't get to the end of the string. This means the component names
1853 // didn't come from the same set *or* we encountered an illegal name.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001854 Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
1855 << std::string(compStr,compStr+1) << SourceRange(CompLoc);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001856 return QualType();
1857 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00001858
Nate Begeman353417a2009-01-18 01:47:54 +00001859 // Ensure no component accessor exceeds the width of the vector type it
1860 // operates on.
1861 if (!HalvingSwizzle) {
Daniel Dunbare013d682009-10-18 20:26:12 +00001862 compStr = CompName->getNameStart();
Nate Begeman353417a2009-01-18 01:47:54 +00001863
1864 if (HexSwizzle)
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001865 compStr++;
Nate Begeman353417a2009-01-18 01:47:54 +00001866
1867 while (*compStr) {
1868 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
1869 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
1870 << baseType << SourceRange(CompLoc);
1871 return QualType();
1872 }
1873 }
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001874 }
Nate Begeman8a997642008-05-09 06:41:27 +00001875
Nate Begeman353417a2009-01-18 01:47:54 +00001876 // If this is a halving swizzle, verify that the base type has an even
1877 // number of elements.
1878 if (HalvingSwizzle && (vecType->getNumElements() & 1U)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001879 Diag(OpLoc, diag::err_ext_vector_component_requires_even)
Chris Lattnerd1625842008-11-24 06:25:27 +00001880 << baseType << SourceRange(CompLoc);
Nate Begeman8a997642008-05-09 06:41:27 +00001881 return QualType();
1882 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00001883
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001884 // The component accessor looks fine - now we need to compute the actual type.
Mike Stumpeed9cac2009-02-19 03:04:26 +00001885 // The vector type is implied by the component accessor. For example,
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001886 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
Nate Begeman353417a2009-01-18 01:47:54 +00001887 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
Nate Begeman8a997642008-05-09 06:41:27 +00001888 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
Nate Begeman353417a2009-01-18 01:47:54 +00001889 unsigned CompSize = HalvingSwizzle ? vecType->getNumElements() / 2
Anders Carlsson8f28f992009-08-26 18:25:21 +00001890 : CompName->getLength();
Nate Begeman353417a2009-01-18 01:47:54 +00001891 if (HexSwizzle)
1892 CompSize--;
1893
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001894 if (CompSize == 1)
1895 return vecType->getElementType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00001896
Nate Begeman213541a2008-04-18 23:10:10 +00001897 QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize);
Mike Stumpeed9cac2009-02-19 03:04:26 +00001898 // Now look up the TypeDefDecl from the vector type. Without this,
Nate Begeman213541a2008-04-18 23:10:10 +00001899 // diagostics look bad. We want extended vector types to appear built-in.
1900 for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) {
1901 if (ExtVectorDecls[i]->getUnderlyingType() == VT)
1902 return Context.getTypedefType(ExtVectorDecls[i]);
Steve Naroffbea0b342007-07-29 16:33:31 +00001903 }
1904 return VT; // should never get here (a typedef type should always be found).
Steve Naroffe1b31fe2007-07-27 22:15:19 +00001905}
1906
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001907static Decl *FindGetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
Anders Carlsson8f28f992009-08-26 18:25:21 +00001908 IdentifierInfo *Member,
Douglas Gregor6ab35242009-04-09 21:40:53 +00001909 const Selector &Sel,
1910 ASTContext &Context) {
Mike Stump1eb44332009-09-09 15:08:12 +00001911
Anders Carlsson8f28f992009-08-26 18:25:21 +00001912 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Member))
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001913 return PD;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001914 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001915 return OMD;
Mike Stump1eb44332009-09-09 15:08:12 +00001916
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001917 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
1918 E = PDecl->protocol_end(); I != E; ++I) {
Mike Stump1eb44332009-09-09 15:08:12 +00001919 if (Decl *D = FindGetterNameDeclFromProtocolList(*I, Member, Sel,
Douglas Gregor6ab35242009-04-09 21:40:53 +00001920 Context))
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001921 return D;
1922 }
1923 return 0;
1924}
1925
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001926static Decl *FindGetterNameDecl(const ObjCObjectPointerType *QIdTy,
Anders Carlsson8f28f992009-08-26 18:25:21 +00001927 IdentifierInfo *Member,
Douglas Gregor6ab35242009-04-09 21:40:53 +00001928 const Selector &Sel,
1929 ASTContext &Context) {
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001930 // Check protocols on qualified interfaces.
1931 Decl *GDecl = 0;
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001932 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001933 E = QIdTy->qual_end(); I != E; ++I) {
Anders Carlsson8f28f992009-08-26 18:25:21 +00001934 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001935 GDecl = PD;
1936 break;
1937 }
1938 // Also must look for a getter name which uses property syntax.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001939 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Sel)) {
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001940 GDecl = OMD;
1941 break;
1942 }
1943 }
1944 if (!GDecl) {
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001945 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001946 E = QIdTy->qual_end(); I != E; ++I) {
1947 // Search in the protocol-qualifier list of current protocol.
Douglas Gregor6ab35242009-04-09 21:40:53 +00001948 GDecl = FindGetterNameDeclFromProtocolList(*I, Member, Sel, Context);
Fariborz Jahanian2ce1be02009-03-19 18:15:34 +00001949 if (GDecl)
1950 return GDecl;
1951 }
1952 }
1953 return GDecl;
1954}
Chris Lattner76a642f2009-02-15 22:43:40 +00001955
Mike Stump1eb44332009-09-09 15:08:12 +00001956Action::OwningExprResult
Anders Carlsson8f28f992009-08-26 18:25:21 +00001957Sema::BuildMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
Sebastian Redl0eb23302009-01-19 00:08:26 +00001958 tok::TokenKind OpKind, SourceLocation MemberLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001959 DeclarationName MemberName,
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001960 bool HasExplicitTemplateArgs,
1961 SourceLocation LAngleLoc,
1962 const TemplateArgument *ExplicitTemplateArgs,
1963 unsigned NumExplicitTemplateArgs,
1964 SourceLocation RAngleLoc,
Douglas Gregorc68afe22009-09-03 21:38:09 +00001965 DeclPtrTy ObjCImpDecl, const CXXScopeSpec *SS,
1966 NamedDecl *FirstQualifierInScope) {
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001967 if (SS && SS->isInvalid())
1968 return ExprError();
1969
Nate Begeman2ef13e52009-08-10 23:49:36 +00001970 // Since this might be a postfix expression, get rid of ParenListExprs.
1971 Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
1972
Anders Carlssonf1b1d592009-05-01 19:30:39 +00001973 Expr *BaseExpr = Base.takeAs<Expr>();
Douglas Gregora71d8192009-09-04 17:36:40 +00001974 assert(BaseExpr && "no base expression");
Mike Stump1eb44332009-09-09 15:08:12 +00001975
Steve Naroff3cc4af82007-12-16 21:42:28 +00001976 // Perform default conversions.
1977 DefaultFunctionArrayConversion(BaseExpr);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001978
Steve Naroffdfa6aae2007-07-26 03:11:44 +00001979 QualType BaseType = BaseExpr->getType();
David Chisnall0f436562009-08-17 16:35:33 +00001980 // If this is an Objective-C pseudo-builtin and a definition is provided then
1981 // use that.
1982 if (BaseType->isObjCIdType()) {
1983 // We have an 'id' type. Rather than fall through, we check if this
1984 // is a reference to 'isa'.
1985 if (BaseType != Context.ObjCIdRedefinitionType) {
1986 BaseType = Context.ObjCIdRedefinitionType;
Eli Friedman73c39ab2009-10-20 08:27:19 +00001987 ImpCastExprToType(BaseExpr, BaseType, CastExpr::CK_BitCast);
David Chisnall0f436562009-08-17 16:35:33 +00001988 }
David Chisnall0f436562009-08-17 16:35:33 +00001989 }
Steve Naroffdfa6aae2007-07-26 03:11:44 +00001990 assert(!BaseType.isNull() && "no type for member expression");
Sebastian Redl0eb23302009-01-19 00:08:26 +00001991
Fariborz Jahanianb2ef1be2009-09-22 16:48:37 +00001992 // Handle properties on ObjC 'Class' types.
1993 if (OpKind == tok::period && BaseType->isObjCClassType()) {
1994 // Also must look for a getter name which uses property syntax.
1995 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1996 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1997 if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1998 ObjCInterfaceDecl *IFace = MD->getClassInterface();
1999 ObjCMethodDecl *Getter;
2000 // FIXME: need to also look locally in the implementation.
2001 if ((Getter = IFace->lookupClassMethod(Sel))) {
2002 // Check the use of this method.
2003 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2004 return ExprError();
2005 }
2006 // If we found a getter then this may be a valid dot-reference, we
2007 // will look for the matching setter, in case it is needed.
2008 Selector SetterSel =
2009 SelectorTable::constructSetterName(PP.getIdentifierTable(),
2010 PP.getSelectorTable(), Member);
2011 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
2012 if (!Setter) {
2013 // If this reference is in an @implementation, also check for 'private'
2014 // methods.
Steve Naroffd789d3d2009-10-01 23:46:04 +00002015 Setter = IFace->lookupPrivateInstanceMethod(SetterSel);
Fariborz Jahanianb2ef1be2009-09-22 16:48:37 +00002016 }
2017 // Look through local category implementations associated with the class.
2018 if (!Setter)
2019 Setter = IFace->getCategoryClassMethod(SetterSel);
2020
2021 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2022 return ExprError();
2023
2024 if (Getter || Setter) {
2025 QualType PType;
2026
2027 if (Getter)
2028 PType = Getter->getResultType();
2029 else
2030 // Get the expression type from Setter's incoming parameter.
2031 PType = (*(Setter->param_end() -1))->getType();
2032 // FIXME: we must check that the setter has property type.
2033 return Owned(new (Context) ObjCImplicitSetterGetterRefExpr(Getter,
2034 PType,
2035 Setter, MemberLoc, BaseExpr));
2036 }
2037 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2038 << MemberName << BaseType);
2039 }
2040 }
2041
2042 if (BaseType->isObjCClassType() &&
2043 BaseType != Context.ObjCClassRedefinitionType) {
2044 BaseType = Context.ObjCClassRedefinitionType;
Eli Friedman73c39ab2009-10-20 08:27:19 +00002045 ImpCastExprToType(BaseExpr, BaseType, CastExpr::CK_BitCast);
Fariborz Jahanianb2ef1be2009-09-22 16:48:37 +00002046 }
2047
Chris Lattner68a057b2008-07-21 04:36:39 +00002048 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
2049 // must have pointer type, and the accessed type is the pointee.
Reid Spencer5f016e22007-07-11 17:01:13 +00002050 if (OpKind == tok::arrow) {
Douglas Gregorc68afe22009-09-03 21:38:09 +00002051 if (BaseType->isDependentType()) {
2052 NestedNameSpecifier *Qualifier = 0;
2053 if (SS) {
2054 Qualifier = static_cast<NestedNameSpecifier *>(SS->getScopeRep());
2055 if (!FirstQualifierInScope)
2056 FirstQualifierInScope = FindFirstQualifierInScope(S, Qualifier);
2057 }
Mike Stump1eb44332009-09-09 15:08:12 +00002058
2059 return Owned(CXXUnresolvedMemberExpr::Create(Context, BaseExpr, true,
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00002060 OpLoc, Qualifier,
Douglas Gregora38c6872009-09-03 16:14:30 +00002061 SS? SS->getRange() : SourceRange(),
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00002062 FirstQualifierInScope,
2063 MemberName,
2064 MemberLoc,
2065 HasExplicitTemplateArgs,
2066 LAngleLoc,
2067 ExplicitTemplateArgs,
2068 NumExplicitTemplateArgs,
2069 RAngleLoc));
Douglas Gregorc68afe22009-09-03 21:38:09 +00002070 }
Ted Kremenek6217b802009-07-29 21:53:49 +00002071 else if (const PointerType *PT = BaseType->getAs<PointerType>())
Steve Naroffdfa6aae2007-07-26 03:11:44 +00002072 BaseType = PT->getPointeeType();
Steve Naroff14108da2009-07-10 23:34:53 +00002073 else if (BaseType->isObjCObjectPointerType())
2074 ;
Steve Naroffdfa6aae2007-07-26 03:11:44 +00002075 else
Sebastian Redl0eb23302009-01-19 00:08:26 +00002076 return ExprError(Diag(MemberLoc,
2077 diag::err_typecheck_member_reference_arrow)
2078 << BaseType << BaseExpr->getSourceRange());
Fariborz Jahanianb2ef1be2009-09-22 16:48:37 +00002079 } else if (BaseType->isDependentType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002080 // Require that the base type isn't a pointer type
Anders Carlsson4ef27702009-05-16 20:31:20 +00002081 // (so we'll report an error for)
2082 // T* t;
2083 // t.f;
Mike Stump1eb44332009-09-09 15:08:12 +00002084 //
Anders Carlsson4ef27702009-05-16 20:31:20 +00002085 // In Obj-C++, however, the above expression is valid, since it could be
2086 // accessing the 'f' property if T is an Obj-C interface. The extra check
2087 // allows this, while still reporting an error if T is a struct pointer.
Ted Kremenek6217b802009-07-29 21:53:49 +00002088 const PointerType *PT = BaseType->getAs<PointerType>();
Anders Carlsson4ef27702009-05-16 20:31:20 +00002089
Mike Stump1eb44332009-09-09 15:08:12 +00002090 if (!PT || (getLangOptions().ObjC1 &&
Douglas Gregorc68afe22009-09-03 21:38:09 +00002091 !PT->getPointeeType()->isRecordType())) {
2092 NestedNameSpecifier *Qualifier = 0;
2093 if (SS) {
2094 Qualifier = static_cast<NestedNameSpecifier *>(SS->getScopeRep());
2095 if (!FirstQualifierInScope)
2096 FirstQualifierInScope = FindFirstQualifierInScope(S, Qualifier);
2097 }
Mike Stump1eb44332009-09-09 15:08:12 +00002098
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00002099 return Owned(CXXUnresolvedMemberExpr::Create(Context,
Mike Stump1eb44332009-09-09 15:08:12 +00002100 BaseExpr, false,
2101 OpLoc,
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00002102 Qualifier,
Douglas Gregora38c6872009-09-03 16:14:30 +00002103 SS? SS->getRange() : SourceRange(),
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00002104 FirstQualifierInScope,
2105 MemberName,
2106 MemberLoc,
2107 HasExplicitTemplateArgs,
2108 LAngleLoc,
2109 ExplicitTemplateArgs,
2110 NumExplicitTemplateArgs,
2111 RAngleLoc));
Douglas Gregorc68afe22009-09-03 21:38:09 +00002112 }
Anders Carlsson4ef27702009-05-16 20:31:20 +00002113 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00002114
Chris Lattner68a057b2008-07-21 04:36:39 +00002115 // Handle field access to simple records. This also handles access to fields
2116 // of the ObjC 'id' struct.
Ted Kremenek6217b802009-07-29 21:53:49 +00002117 if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
Steve Naroffdfa6aae2007-07-26 03:11:44 +00002118 RecordDecl *RDecl = RTy->getDecl();
Douglas Gregor86447ec2009-03-09 16:13:40 +00002119 if (RequireCompleteType(OpLoc, BaseType,
Anders Carlssonb7906612009-08-26 23:45:07 +00002120 PDiag(diag::err_typecheck_incomplete_tag)
2121 << BaseExpr->getSourceRange()))
Douglas Gregor4ec339f2009-01-19 19:26:10 +00002122 return ExprError();
2123
Douglas Gregorfe85ced2009-08-06 03:17:00 +00002124 DeclContext *DC = RDecl;
2125 if (SS && SS->isSet()) {
2126 // If the member name was a qualified-id, look into the
2127 // nested-name-specifier.
2128 DC = computeDeclContext(*SS, false);
Douglas Gregor8d1c9ae2009-10-17 22:37:54 +00002129
2130 if (!isa<TypeDecl>(DC)) {
2131 Diag(MemberLoc, diag::err_qualified_member_nonclass)
2132 << DC << SS->getRange();
2133 return ExprError();
2134 }
Mike Stump1eb44332009-09-09 15:08:12 +00002135
2136 // FIXME: If DC is not computable, we should build a
Douglas Gregorfe85ced2009-08-06 03:17:00 +00002137 // CXXUnresolvedMemberExpr.
2138 assert(DC && "Cannot handle non-computable dependent contexts in lookup");
2139 }
2140
Steve Naroffdfa6aae2007-07-26 03:11:44 +00002141 // The record definition is complete, now make sure the member is valid.
John McCallf36e02d2009-10-09 21:13:30 +00002142 LookupResult Result;
2143 LookupQualifiedName(Result, DC, MemberName, LookupMemberName, false);
Douglas Gregor7176fff2009-01-15 00:26:24 +00002144
John McCallf36e02d2009-10-09 21:13:30 +00002145 if (Result.empty())
Douglas Gregor3f093272009-10-13 21:16:44 +00002146 return ExprError(Diag(MemberLoc, diag::err_no_member)
2147 << MemberName << DC << BaseExpr->getSourceRange());
Chris Lattnera3d25242009-03-31 08:18:48 +00002148 if (Result.isAmbiguous()) {
Anders Carlsson8f28f992009-08-26 18:25:21 +00002149 DiagnoseAmbiguousLookup(Result, MemberName, MemberLoc,
2150 BaseExpr->getSourceRange());
Sebastian Redl0eb23302009-01-19 00:08:26 +00002151 return ExprError();
Chris Lattnera3d25242009-03-31 08:18:48 +00002152 }
Mike Stump1eb44332009-09-09 15:08:12 +00002153
John McCallf36e02d2009-10-09 21:13:30 +00002154 NamedDecl *MemberDecl = Result.getAsSingleDecl(Context);
2155
Douglas Gregora38c6872009-09-03 16:14:30 +00002156 if (SS && SS->isSet()) {
John McCallf36e02d2009-10-09 21:13:30 +00002157 TypeDecl* TyD = cast<TypeDecl>(MemberDecl->getDeclContext());
Mike Stump1eb44332009-09-09 15:08:12 +00002158 QualType BaseTypeCanon
Douglas Gregora38c6872009-09-03 16:14:30 +00002159 = Context.getCanonicalType(BaseType).getUnqualifiedType();
Mike Stump1eb44332009-09-09 15:08:12 +00002160 QualType MemberTypeCanon
John McCallf36e02d2009-10-09 21:13:30 +00002161 = Context.getCanonicalType(Context.getTypeDeclType(TyD));
Mike Stump1eb44332009-09-09 15:08:12 +00002162
Douglas Gregora38c6872009-09-03 16:14:30 +00002163 if (BaseTypeCanon != MemberTypeCanon &&
2164 !IsDerivedFrom(BaseTypeCanon, MemberTypeCanon))
2165 return ExprError(Diag(SS->getBeginLoc(),
2166 diag::err_not_direct_base_or_virtual)
2167 << MemberTypeCanon << BaseTypeCanon);
2168 }
Mike Stump1eb44332009-09-09 15:08:12 +00002169
Chris Lattner56cd21b2009-02-13 22:08:30 +00002170 // If the decl being referenced had an error, return an error for this
2171 // sub-expr without emitting another error, in order to avoid cascading
2172 // error cases.
2173 if (MemberDecl->isInvalidDecl())
2174 return ExprError();
Mike Stumpeed9cac2009-02-19 03:04:26 +00002175
Anders Carlsson0f728562009-09-10 20:48:14 +00002176 bool ShouldCheckUse = true;
2177 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MemberDecl)) {
2178 // Don't diagnose the use of a virtual member function unless it's
2179 // explicitly qualified.
2180 if (MD->isVirtual() && (!SS || !SS->isSet()))
2181 ShouldCheckUse = false;
2182 }
Daniel Dunbar7e88a602009-09-17 06:31:17 +00002183
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002184 // Check the use of this field
Anders Carlsson0f728562009-09-10 20:48:14 +00002185 if (ShouldCheckUse && DiagnoseUseOfDecl(MemberDecl, MemberLoc))
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002186 return ExprError();
Chris Lattner56cd21b2009-02-13 22:08:30 +00002187
Douglas Gregor3fc749d2008-12-23 00:26:44 +00002188 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
Douglas Gregorbcbffc42009-01-07 00:43:41 +00002189 // We may have found a field within an anonymous union or struct
2190 // (C++ [class.union]).
2191 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
Sebastian Redlcd965b92009-01-18 18:53:16 +00002192 return BuildAnonymousStructUnionMemberReference(MemberLoc, FD,
Sebastian Redl0eb23302009-01-19 00:08:26 +00002193 BaseExpr, OpLoc);
Douglas Gregorbcbffc42009-01-07 00:43:41 +00002194
Douglas Gregor86f19402008-12-20 23:49:58 +00002195 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
Douglas Gregor3fc749d2008-12-23 00:26:44 +00002196 QualType MemberType = FD->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +00002197 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>())
Douglas Gregor86f19402008-12-20 23:49:58 +00002198 MemberType = Ref->getPointeeType();
2199 else {
John McCall0953e762009-09-24 19:53:00 +00002200 Qualifiers BaseQuals = BaseType.getQualifiers();
2201 BaseQuals.removeObjCGCAttr();
2202 if (FD->isMutable()) BaseQuals.removeConst();
2203
2204 Qualifiers MemberQuals
2205 = Context.getCanonicalType(MemberType).getQualifiers();
2206
2207 Qualifiers Combined = BaseQuals + MemberQuals;
2208 if (Combined != MemberQuals)
2209 MemberType = Context.getQualifiedType(MemberType, Combined);
Douglas Gregor86f19402008-12-20 23:49:58 +00002210 }
Eli Friedman51019072008-02-06 22:48:16 +00002211
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002212 MarkDeclarationReferenced(MemberLoc, FD);
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +00002213 if (PerformObjectMemberConversion(BaseExpr, FD))
2214 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00002215 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002216 FD, MemberLoc, MemberType));
Chris Lattnera3d25242009-03-31 08:18:48 +00002217 }
Mike Stump1eb44332009-09-09 15:08:12 +00002218
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002219 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
2220 MarkDeclarationReferenced(MemberLoc, MemberDecl);
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002221 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
2222 Var, MemberLoc,
2223 Var->getType().getNonReferenceType()));
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002224 }
2225 if (FunctionDecl *MemberFn = dyn_cast<FunctionDecl>(MemberDecl)) {
2226 MarkDeclarationReferenced(MemberLoc, MemberDecl);
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002227 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
2228 MemberFn, MemberLoc,
2229 MemberFn->getType()));
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002230 }
Mike Stump1eb44332009-09-09 15:08:12 +00002231 if (FunctionTemplateDecl *FunTmpl
Douglas Gregor6b906862009-08-21 00:16:32 +00002232 = dyn_cast<FunctionTemplateDecl>(MemberDecl)) {
2233 MarkDeclarationReferenced(MemberLoc, MemberDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00002234
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002235 if (HasExplicitTemplateArgs)
Mike Stump1eb44332009-09-09 15:08:12 +00002236 return Owned(MemberExpr::Create(Context, BaseExpr, OpKind == tok::arrow,
2237 (NestedNameSpecifier *)(SS? SS->getScopeRep() : 0),
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002238 SS? SS->getRange() : SourceRange(),
Mike Stump1eb44332009-09-09 15:08:12 +00002239 FunTmpl, MemberLoc, true,
2240 LAngleLoc, ExplicitTemplateArgs,
2241 NumExplicitTemplateArgs, RAngleLoc,
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002242 Context.OverloadTy));
Mike Stump1eb44332009-09-09 15:08:12 +00002243
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002244 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
2245 FunTmpl, MemberLoc,
2246 Context.OverloadTy));
Douglas Gregor6b906862009-08-21 00:16:32 +00002247 }
Chris Lattnera3d25242009-03-31 08:18:48 +00002248 if (OverloadedFunctionDecl *Ovl
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002249 = dyn_cast<OverloadedFunctionDecl>(MemberDecl)) {
2250 if (HasExplicitTemplateArgs)
Mike Stump1eb44332009-09-09 15:08:12 +00002251 return Owned(MemberExpr::Create(Context, BaseExpr, OpKind == tok::arrow,
2252 (NestedNameSpecifier *)(SS? SS->getScopeRep() : 0),
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002253 SS? SS->getRange() : SourceRange(),
Mike Stump1eb44332009-09-09 15:08:12 +00002254 Ovl, MemberLoc, true,
2255 LAngleLoc, ExplicitTemplateArgs,
2256 NumExplicitTemplateArgs, RAngleLoc,
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002257 Context.OverloadTy));
2258
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002259 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
2260 Ovl, MemberLoc, Context.OverloadTy));
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00002261 }
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002262 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
2263 MarkDeclarationReferenced(MemberLoc, MemberDecl);
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +00002264 return Owned(BuildMemberExpr(Context, BaseExpr, OpKind == tok::arrow, SS,
2265 Enum, MemberLoc, Enum->getType()));
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002266 }
Chris Lattnera3d25242009-03-31 08:18:48 +00002267 if (isa<TypeDecl>(MemberDecl))
Sebastian Redl0eb23302009-01-19 00:08:26 +00002268 return ExprError(Diag(MemberLoc,diag::err_typecheck_member_reference_type)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002269 << MemberName << int(OpKind == tok::arrow));
Eli Friedman51019072008-02-06 22:48:16 +00002270
Douglas Gregor86f19402008-12-20 23:49:58 +00002271 // We found a declaration kind that we didn't expect. This is a
2272 // generic error message that tells the user that she can't refer
2273 // to this member with '.' or '->'.
Sebastian Redl0eb23302009-01-19 00:08:26 +00002274 return ExprError(Diag(MemberLoc,
2275 diag::err_typecheck_member_reference_unknown)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002276 << MemberName << int(OpKind == tok::arrow));
Chris Lattnerfb173ec2008-07-21 04:28:12 +00002277 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00002278
Douglas Gregora71d8192009-09-04 17:36:40 +00002279 // Handle pseudo-destructors (C++ [expr.pseudo]). Since anything referring
2280 // into a record type was handled above, any destructor we see here is a
2281 // pseudo-destructor.
2282 if (MemberName.getNameKind() == DeclarationName::CXXDestructorName) {
2283 // C++ [expr.pseudo]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00002284 // The left hand side of the dot operator shall be of scalar type. The
2285 // left hand side of the arrow operator shall be of pointer to scalar
Douglas Gregora71d8192009-09-04 17:36:40 +00002286 // type.
2287 if (!BaseType->isScalarType())
2288 return Owned(Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
2289 << BaseType << BaseExpr->getSourceRange());
Mike Stump1eb44332009-09-09 15:08:12 +00002290
Douglas Gregora71d8192009-09-04 17:36:40 +00002291 // [...] The type designated by the pseudo-destructor-name shall be the
2292 // same as the object type.
2293 if (!MemberName.getCXXNameType()->isDependentType() &&
2294 !Context.hasSameUnqualifiedType(BaseType, MemberName.getCXXNameType()))
2295 return Owned(Diag(OpLoc, diag::err_pseudo_dtor_type_mismatch)
2296 << BaseType << MemberName.getCXXNameType()
2297 << BaseExpr->getSourceRange() << SourceRange(MemberLoc));
Mike Stump1eb44332009-09-09 15:08:12 +00002298
2299 // [...] Furthermore, the two type-names in a pseudo-destructor-name of
Douglas Gregora71d8192009-09-04 17:36:40 +00002300 // the form
2301 //
Mike Stump1eb44332009-09-09 15:08:12 +00002302 // ::[opt] nested-name-specifier[opt] type-name :: ̃ type-name
2303 //
Douglas Gregora71d8192009-09-04 17:36:40 +00002304 // shall designate the same scalar type.
2305 //
2306 // FIXME: DPG can't see any way to trigger this particular clause, so it
2307 // isn't checked here.
Mike Stump1eb44332009-09-09 15:08:12 +00002308
Douglas Gregora71d8192009-09-04 17:36:40 +00002309 // FIXME: We've lost the precise spelling of the type by going through
2310 // DeclarationName. Can we do better?
2311 return Owned(new (Context) CXXPseudoDestructorExpr(Context, BaseExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00002312 OpKind == tok::arrow,
Douglas Gregora71d8192009-09-04 17:36:40 +00002313 OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002314 (NestedNameSpecifier *)(SS? SS->getScopeRep() : 0),
Douglas Gregora71d8192009-09-04 17:36:40 +00002315 SS? SS->getRange() : SourceRange(),
2316 MemberName.getCXXNameType(),
2317 MemberLoc));
2318 }
Mike Stump1eb44332009-09-09 15:08:12 +00002319
Chris Lattnera38e6b12008-07-21 04:59:05 +00002320 // Handle access to Objective-C instance variables, such as "Obj->ivar" and
2321 // (*Obj).ivar.
Steve Naroff14108da2009-07-10 23:34:53 +00002322 if ((OpKind == tok::arrow && BaseType->isObjCObjectPointerType()) ||
2323 (OpKind == tok::period && BaseType->isObjCInterfaceType())) {
John McCall183700f2009-09-21 23:43:11 +00002324 const ObjCObjectPointerType *OPT = BaseType->getAs<ObjCObjectPointerType>();
Mike Stump1eb44332009-09-09 15:08:12 +00002325 const ObjCInterfaceType *IFaceT =
John McCall183700f2009-09-21 23:43:11 +00002326 OPT ? OPT->getInterfaceType() : BaseType->getAs<ObjCInterfaceType>();
Steve Naroffc70e8d92009-07-16 00:25:06 +00002327 if (IFaceT) {
Anders Carlsson8f28f992009-08-26 18:25:21 +00002328 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
2329
Steve Naroffc70e8d92009-07-16 00:25:06 +00002330 ObjCInterfaceDecl *IDecl = IFaceT->getDecl();
2331 ObjCInterfaceDecl *ClassDeclared;
Anders Carlsson8f28f992009-08-26 18:25:21 +00002332 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
Mike Stump1eb44332009-09-09 15:08:12 +00002333
Steve Naroffc70e8d92009-07-16 00:25:06 +00002334 if (IV) {
2335 // If the decl being referenced had an error, return an error for this
2336 // sub-expr without emitting another error, in order to avoid cascading
2337 // error cases.
2338 if (IV->isInvalidDecl())
2339 return ExprError();
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002340
Steve Naroffc70e8d92009-07-16 00:25:06 +00002341 // Check whether we can reference this field.
2342 if (DiagnoseUseOfDecl(IV, MemberLoc))
2343 return ExprError();
2344 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
2345 IV->getAccessControl() != ObjCIvarDecl::Package) {
2346 ObjCInterfaceDecl *ClassOfMethodDecl = 0;
2347 if (ObjCMethodDecl *MD = getCurMethodDecl())
2348 ClassOfMethodDecl = MD->getClassInterface();
2349 else if (ObjCImpDecl && getCurFunctionDecl()) {
2350 // Case of a c-function declared inside an objc implementation.
2351 // FIXME: For a c-style function nested inside an objc implementation
2352 // class, there is no implementation context available, so we pass
2353 // down the context as argument to this routine. Ideally, this context
2354 // need be passed down in the AST node and somehow calculated from the
2355 // AST for a function decl.
2356 Decl *ImplDecl = ObjCImpDecl.getAs<Decl>();
Mike Stump1eb44332009-09-09 15:08:12 +00002357 if (ObjCImplementationDecl *IMPD =
Steve Naroffc70e8d92009-07-16 00:25:06 +00002358 dyn_cast<ObjCImplementationDecl>(ImplDecl))
2359 ClassOfMethodDecl = IMPD->getClassInterface();
2360 else if (ObjCCategoryImplDecl* CatImplClass =
2361 dyn_cast<ObjCCategoryImplDecl>(ImplDecl))
2362 ClassOfMethodDecl = CatImplClass->getClassInterface();
2363 }
Mike Stump1eb44332009-09-09 15:08:12 +00002364
2365 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
2366 if (ClassDeclared != IDecl ||
Steve Naroffc70e8d92009-07-16 00:25:06 +00002367 ClassOfMethodDecl != ClassDeclared)
Mike Stump1eb44332009-09-09 15:08:12 +00002368 Diag(MemberLoc, diag::error_private_ivar_access)
Steve Naroffc70e8d92009-07-16 00:25:06 +00002369 << IV->getDeclName();
Mike Stumpac5fc7c2009-08-04 21:02:39 +00002370 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
2371 // @protected
Mike Stump1eb44332009-09-09 15:08:12 +00002372 Diag(MemberLoc, diag::error_protected_ivar_access)
Steve Naroffc70e8d92009-07-16 00:25:06 +00002373 << IV->getDeclName();
Steve Naroffb06d8752009-03-04 18:34:24 +00002374 }
Steve Naroffc70e8d92009-07-16 00:25:06 +00002375
2376 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(),
2377 MemberLoc, BaseExpr,
2378 OpKind == tok::arrow));
Fariborz Jahanian935fd762009-03-03 01:21:12 +00002379 }
Steve Naroffc70e8d92009-07-16 00:25:06 +00002380 return ExprError(Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002381 << IDecl->getDeclName() << MemberName
Steve Naroffc70e8d92009-07-16 00:25:06 +00002382 << BaseExpr->getSourceRange());
Fariborz Jahanianaaa63a72008-12-13 22:20:28 +00002383 }
Chris Lattnerfb173ec2008-07-21 04:28:12 +00002384 }
Steve Naroffde2e22d2009-07-15 18:40:39 +00002385 // Handle properties on 'id' and qualified "id".
Mike Stump1eb44332009-09-09 15:08:12 +00002386 if (OpKind == tok::period && (BaseType->isObjCIdType() ||
Steve Naroffde2e22d2009-07-15 18:40:39 +00002387 BaseType->isObjCQualifiedIdType())) {
John McCall183700f2009-09-21 23:43:11 +00002388 const ObjCObjectPointerType *QIdTy = BaseType->getAs<ObjCObjectPointerType>();
Anders Carlsson8f28f992009-08-26 18:25:21 +00002389 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00002390
Steve Naroff14108da2009-07-10 23:34:53 +00002391 // Check protocols on qualified interfaces.
Anders Carlsson8f28f992009-08-26 18:25:21 +00002392 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
Steve Naroff14108da2009-07-10 23:34:53 +00002393 if (Decl *PMDecl = FindGetterNameDecl(QIdTy, Member, Sel, Context)) {
2394 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
2395 // Check the use of this declaration
2396 if (DiagnoseUseOfDecl(PD, MemberLoc))
2397 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00002398
Steve Naroff14108da2009-07-10 23:34:53 +00002399 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2400 MemberLoc, BaseExpr));
2401 }
2402 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
2403 // Check the use of this method.
2404 if (DiagnoseUseOfDecl(OMD, MemberLoc))
2405 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00002406
Steve Naroff14108da2009-07-10 23:34:53 +00002407 return Owned(new (Context) ObjCMessageExpr(BaseExpr, Sel,
Mike Stump1eb44332009-09-09 15:08:12 +00002408 OMD->getResultType(),
2409 OMD, OpLoc, MemberLoc,
Steve Naroff14108da2009-07-10 23:34:53 +00002410 NULL, 0));
2411 }
2412 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00002413
Steve Naroff14108da2009-07-10 23:34:53 +00002414 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002415 << MemberName << BaseType);
Steve Naroff14108da2009-07-10 23:34:53 +00002416 }
Chris Lattnera38e6b12008-07-21 04:59:05 +00002417 // Handle Objective-C property access, which is "Obj.property" where Obj is a
2418 // pointer to a (potentially qualified) interface type.
Steve Naroff14108da2009-07-10 23:34:53 +00002419 const ObjCObjectPointerType *OPT;
Mike Stump1eb44332009-09-09 15:08:12 +00002420 if (OpKind == tok::period &&
Steve Naroff14108da2009-07-10 23:34:53 +00002421 (OPT = BaseType->getAsObjCInterfacePointerType())) {
2422 const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
2423 ObjCInterfaceDecl *IFace = IFaceT->getDecl();
Anders Carlsson8f28f992009-08-26 18:25:21 +00002424 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00002425
Daniel Dunbar2307d312008-09-03 01:05:41 +00002426 // Search for a declared property first.
Anders Carlsson8f28f992009-08-26 18:25:21 +00002427 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Member)) {
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002428 // Check whether we can reference this property.
2429 if (DiagnoseUseOfDecl(PD, MemberLoc))
2430 return ExprError();
Fariborz Jahanian4c2743f2009-05-08 19:36:34 +00002431 QualType ResTy = PD->getType();
Anders Carlsson8f28f992009-08-26 18:25:21 +00002432 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002433 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
Fariborz Jahanianc001e892009-05-08 20:20:55 +00002434 if (DiagnosePropertyAccessorMismatch(PD, Getter, MemberLoc))
2435 ResTy = Getter->getResultType();
Fariborz Jahanian4c2743f2009-05-08 19:36:34 +00002436 return Owned(new (Context) ObjCPropertyRefExpr(PD, ResTy,
Chris Lattner7eba82e2009-02-16 18:35:08 +00002437 MemberLoc, BaseExpr));
2438 }
Daniel Dunbar2307d312008-09-03 01:05:41 +00002439 // Check protocols on qualified interfaces.
Steve Naroff67ef8ea2009-07-20 17:56:53 +00002440 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
2441 E = OPT->qual_end(); I != E; ++I)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002442 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002443 // Check whether we can reference this property.
2444 if (DiagnoseUseOfDecl(PD, MemberLoc))
2445 return ExprError();
Chris Lattner7eba82e2009-02-16 18:35:08 +00002446
Steve Naroff6ece14c2009-01-21 00:14:39 +00002447 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
Chris Lattner7eba82e2009-02-16 18:35:08 +00002448 MemberLoc, BaseExpr));
2449 }
Steve Naroff14108da2009-07-10 23:34:53 +00002450 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
2451 E = OPT->qual_end(); I != E; ++I)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002452 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
Steve Naroff14108da2009-07-10 23:34:53 +00002453 // Check whether we can reference this property.
2454 if (DiagnoseUseOfDecl(PD, MemberLoc))
2455 return ExprError();
Daniel Dunbar2307d312008-09-03 01:05:41 +00002456
Steve Naroff14108da2009-07-10 23:34:53 +00002457 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2458 MemberLoc, BaseExpr));
2459 }
Daniel Dunbar2307d312008-09-03 01:05:41 +00002460 // If that failed, look for an "implicit" property by seeing if the nullary
2461 // selector is implemented.
2462
2463 // FIXME: The logic for looking up nullary and unary selectors should be
2464 // shared with the code in ActOnInstanceMessage.
2465
Anders Carlsson8f28f992009-08-26 18:25:21 +00002466 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002467 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002468
Daniel Dunbar2307d312008-09-03 01:05:41 +00002469 // If this reference is in an @implementation, check for 'private' methods.
2470 if (!Getter)
Steve Naroffd789d3d2009-10-01 23:46:04 +00002471 Getter = IFace->lookupPrivateInstanceMethod(Sel);
Daniel Dunbar2307d312008-09-03 01:05:41 +00002472
Steve Naroff7692ed62008-10-22 19:16:27 +00002473 // Look through local category implementations associated with the class.
Argyrios Kyrtzidis1cb35dd2009-07-21 00:06:20 +00002474 if (!Getter)
2475 Getter = IFace->getCategoryInstanceMethod(Sel);
Daniel Dunbar2307d312008-09-03 01:05:41 +00002476 if (Getter) {
Douglas Gregor48f3bb92009-02-18 21:56:37 +00002477 // Check if we can reference this property.
2478 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2479 return ExprError();
Steve Naroff1ca66942009-03-11 13:48:17 +00002480 }
2481 // If we found a getter then this may be a valid dot-reference, we
2482 // will look for the matching setter, in case it is needed.
Mike Stump1eb44332009-09-09 15:08:12 +00002483 Selector SetterSel =
2484 SelectorTable::constructSetterName(PP.getIdentifierTable(),
Anders Carlsson8f28f992009-08-26 18:25:21 +00002485 PP.getSelectorTable(), Member);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002486 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
Steve Naroff1ca66942009-03-11 13:48:17 +00002487 if (!Setter) {
2488 // If this reference is in an @implementation, also check for 'private'
2489 // methods.
Steve Naroffd789d3d2009-10-01 23:46:04 +00002490 Setter = IFace->lookupPrivateInstanceMethod(SetterSel);
Steve Naroff1ca66942009-03-11 13:48:17 +00002491 }
2492 // Look through local category implementations associated with the class.
Argyrios Kyrtzidis1cb35dd2009-07-21 00:06:20 +00002493 if (!Setter)
2494 Setter = IFace->getCategoryInstanceMethod(SetterSel);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002495
Steve Naroff1ca66942009-03-11 13:48:17 +00002496 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2497 return ExprError();
2498
2499 if (Getter || Setter) {
2500 QualType PType;
2501
2502 if (Getter)
2503 PType = Getter->getResultType();
Fariborz Jahanian154440e2009-08-18 20:50:23 +00002504 else
2505 // Get the expression type from Setter's incoming parameter.
2506 PType = (*(Setter->param_end() -1))->getType();
Steve Naroff1ca66942009-03-11 13:48:17 +00002507 // FIXME: we must check that the setter has property type.
Fariborz Jahanian09105f52009-08-20 17:02:02 +00002508 return Owned(new (Context) ObjCImplicitSetterGetterRefExpr(Getter, PType,
Steve Naroff1ca66942009-03-11 13:48:17 +00002509 Setter, MemberLoc, BaseExpr));
2510 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00002511 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
Anders Carlsson8f28f992009-08-26 18:25:21 +00002512 << MemberName << BaseType);
Fariborz Jahanian232220c2007-11-12 22:29:28 +00002513 }
Mike Stump1eb44332009-09-09 15:08:12 +00002514
Steve Narofff242b1b2009-07-24 17:54:45 +00002515 // Handle the following exceptional case (*Obj).isa.
Mike Stump1eb44332009-09-09 15:08:12 +00002516 if (OpKind == tok::period &&
Steve Narofff242b1b2009-07-24 17:54:45 +00002517 BaseType->isSpecificBuiltinType(BuiltinType::ObjCId) &&
Anders Carlsson8f28f992009-08-26 18:25:21 +00002518 MemberName.getAsIdentifierInfo()->isStr("isa"))
Steve Narofff242b1b2009-07-24 17:54:45 +00002519 return Owned(new (Context) ObjCIsaExpr(BaseExpr, false, MemberLoc,
2520 Context.getObjCIdType()));
2521
Chris Lattnerfb173ec2008-07-21 04:28:12 +00002522 // Handle 'field access' to vectors, such as 'V.xx'.
Chris Lattner73525de2009-02-16 21:11:58 +00002523 if (BaseType->isExtVectorType()) {
Anders Carlsson8f28f992009-08-26 18:25:21 +00002524 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
Chris Lattnerfb173ec2008-07-21 04:28:12 +00002525 QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc);
2526 if (ret.isNull())
Sebastian Redl0eb23302009-01-19 00:08:26 +00002527 return ExprError();
Anders Carlsson8f28f992009-08-26 18:25:21 +00002528 return Owned(new (Context) ExtVectorElementExpr(ret, BaseExpr, *Member,
Steve Naroff6ece14c2009-01-21 00:14:39 +00002529 MemberLoc));
Chris Lattnerfb173ec2008-07-21 04:28:12 +00002530 }
Sebastian Redl0eb23302009-01-19 00:08:26 +00002531
Douglas Gregor214f31a2009-03-27 06:00:30 +00002532 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union)
2533 << BaseType << BaseExpr->getSourceRange();
2534
2535 // If the user is trying to apply -> or . to a function or function
2536 // pointer, it's probably because they forgot parentheses to call
2537 // the function. Suggest the addition of those parentheses.
Mike Stump1eb44332009-09-09 15:08:12 +00002538 if (BaseType == Context.OverloadTy ||
Douglas Gregor214f31a2009-03-27 06:00:30 +00002539 BaseType->isFunctionType() ||
Mike Stump1eb44332009-09-09 15:08:12 +00002540 (BaseType->isPointerType() &&
Ted Kremenek6217b802009-07-29 21:53:49 +00002541 BaseType->getAs<PointerType>()->isFunctionType())) {
Douglas Gregor214f31a2009-03-27 06:00:30 +00002542 SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd());
2543 Diag(Loc, diag::note_member_reference_needs_call)
2544 << CodeModificationHint::CreateInsertion(Loc, "()");
2545 }
2546
2547 return ExprError();
Reid Spencer5f016e22007-07-11 17:01:13 +00002548}
2549
Anders Carlsson8f28f992009-08-26 18:25:21 +00002550Action::OwningExprResult
2551Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
2552 tok::TokenKind OpKind, SourceLocation MemberLoc,
2553 IdentifierInfo &Member,
2554 DeclPtrTy ObjCImpDecl, const CXXScopeSpec *SS) {
Mike Stump1eb44332009-09-09 15:08:12 +00002555 return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, MemberLoc,
Anders Carlsson8f28f992009-08-26 18:25:21 +00002556 DeclarationName(&Member), ObjCImpDecl, SS);
2557}
2558
Anders Carlsson56c5e332009-08-25 03:49:14 +00002559Sema::OwningExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
2560 FunctionDecl *FD,
2561 ParmVarDecl *Param) {
2562 if (Param->hasUnparsedDefaultArg()) {
2563 Diag (CallLoc,
2564 diag::err_use_of_default_argument_to_function_declared_later) <<
2565 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
Mike Stump1eb44332009-09-09 15:08:12 +00002566 Diag(UnparsedDefaultArgLocs[Param],
Anders Carlsson56c5e332009-08-25 03:49:14 +00002567 diag::note_default_argument_declared_here);
2568 } else {
2569 if (Param->hasUninstantiatedDefaultArg()) {
2570 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
2571
2572 // Instantiate the expression.
Douglas Gregord6350ae2009-08-28 20:31:08 +00002573 MultiLevelTemplateArgumentList ArgList = getTemplateInstantiationArgs(FD);
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002574
Mike Stump1eb44332009-09-09 15:08:12 +00002575 InstantiatingTemplate Inst(*this, CallLoc, Param,
2576 ArgList.getInnermost().getFlatArgumentList(),
Douglas Gregord6350ae2009-08-28 20:31:08 +00002577 ArgList.getInnermost().flat_size());
Anders Carlsson56c5e332009-08-25 03:49:14 +00002578
John McCallce3ff2b2009-08-25 22:02:44 +00002579 OwningExprResult Result = SubstExpr(UninstExpr, ArgList);
Mike Stump1eb44332009-09-09 15:08:12 +00002580 if (Result.isInvalid())
Anders Carlsson56c5e332009-08-25 03:49:14 +00002581 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00002582
2583 if (SetParamDefaultArgument(Param, move(Result),
Anders Carlsson56c5e332009-08-25 03:49:14 +00002584 /*FIXME:EqualLoc*/
2585 UninstExpr->getSourceRange().getBegin()))
2586 return ExprError();
2587 }
Mike Stump1eb44332009-09-09 15:08:12 +00002588
Anders Carlsson56c5e332009-08-25 03:49:14 +00002589 Expr *DefaultExpr = Param->getDefaultArg();
Mike Stump1eb44332009-09-09 15:08:12 +00002590
Anders Carlsson56c5e332009-08-25 03:49:14 +00002591 // If the default expression creates temporaries, we need to
2592 // push them to the current stack of expression temporaries so they'll
2593 // be properly destroyed.
Mike Stump1eb44332009-09-09 15:08:12 +00002594 if (CXXExprWithTemporaries *E
Anders Carlsson56c5e332009-08-25 03:49:14 +00002595 = dyn_cast_or_null<CXXExprWithTemporaries>(DefaultExpr)) {
Mike Stump1eb44332009-09-09 15:08:12 +00002596 assert(!E->shouldDestroyTemporaries() &&
Anders Carlsson56c5e332009-08-25 03:49:14 +00002597 "Can't destroy temporaries in a default argument expr!");
2598 for (unsigned I = 0, N = E->getNumTemporaries(); I != N; ++I)
2599 ExprTemporaries.push_back(E->getTemporary(I));
2600 }
2601 }
2602
2603 // We already type-checked the argument, so we know it works.
2604 return Owned(CXXDefaultArgExpr::Create(Context, Param));
2605}
2606
Douglas Gregor88a35142008-12-22 05:46:06 +00002607/// ConvertArgumentsForCall - Converts the arguments specified in
2608/// Args/NumArgs to the parameter types of the function FDecl with
2609/// function prototype Proto. Call is the call expression itself, and
2610/// Fn is the function expression. For a C++ member function, this
2611/// routine does not attempt to convert the object argument. Returns
2612/// true if the call is ill-formed.
Mike Stumpeed9cac2009-02-19 03:04:26 +00002613bool
2614Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00002615 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00002616 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00002617 Expr **Args, unsigned NumArgs,
2618 SourceLocation RParenLoc) {
Mike Stumpeed9cac2009-02-19 03:04:26 +00002619 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
Douglas Gregor88a35142008-12-22 05:46:06 +00002620 // assignment, to the types of the corresponding parameter, ...
2621 unsigned NumArgsInProto = Proto->getNumArgs();
2622 unsigned NumArgsToCheck = NumArgs;
Douglas Gregor3fd56d72009-01-23 21:30:56 +00002623 bool Invalid = false;
2624
Douglas Gregor88a35142008-12-22 05:46:06 +00002625 // If too few arguments are available (and we don't have default
2626 // arguments for the remaining parameters), don't make the call.
2627 if (NumArgs < NumArgsInProto) {
2628 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments())
2629 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args)
2630 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange();
2631 // Use default arguments for missing arguments
2632 NumArgsToCheck = NumArgsInProto;
Ted Kremenek8189cde2009-02-07 01:47:29 +00002633 Call->setNumArgs(Context, NumArgsInProto);
Douglas Gregor88a35142008-12-22 05:46:06 +00002634 }
2635
2636 // If too many are passed and not variadic, error on the extras and drop
2637 // them.
2638 if (NumArgs > NumArgsInProto) {
2639 if (!Proto->isVariadic()) {
2640 Diag(Args[NumArgsInProto]->getLocStart(),
2641 diag::err_typecheck_call_too_many_args)
2642 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange()
2643 << SourceRange(Args[NumArgsInProto]->getLocStart(),
2644 Args[NumArgs-1]->getLocEnd());
2645 // This deletes the extra arguments.
Ted Kremenek8189cde2009-02-07 01:47:29 +00002646 Call->setNumArgs(Context, NumArgsInProto);
Douglas Gregor3fd56d72009-01-23 21:30:56 +00002647 Invalid = true;
Douglas Gregor88a35142008-12-22 05:46:06 +00002648 }
2649 NumArgsToCheck = NumArgsInProto;
2650 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00002651
Douglas Gregor88a35142008-12-22 05:46:06 +00002652 // Continue to check argument types (even if we have too few/many args).
2653 for (unsigned i = 0; i != NumArgsToCheck; i++) {
2654 QualType ProtoArgType = Proto->getArgType(i);
Mike Stumpeed9cac2009-02-19 03:04:26 +00002655
Douglas Gregor88a35142008-12-22 05:46:06 +00002656 Expr *Arg;
Douglas Gregor61366e92008-12-24 00:01:03 +00002657 if (i < NumArgs) {
Douglas Gregor88a35142008-12-22 05:46:06 +00002658 Arg = Args[i];
Douglas Gregor61366e92008-12-24 00:01:03 +00002659
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002660 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2661 ProtoArgType,
Anders Carlssonb7906612009-08-26 23:45:07 +00002662 PDiag(diag::err_call_incomplete_argument)
2663 << Arg->getSourceRange()))
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002664 return true;
2665
Douglas Gregor61366e92008-12-24 00:01:03 +00002666 // Pass the argument.
2667 if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
2668 return true;
Anders Carlsson5e300d12009-06-12 16:51:40 +00002669 } else {
Anders Carlssoned961f92009-08-25 02:29:20 +00002670 ParmVarDecl *Param = FDecl->getParamDecl(i);
Mike Stump1eb44332009-09-09 15:08:12 +00002671
2672 OwningExprResult ArgExpr =
Anders Carlsson56c5e332009-08-25 03:49:14 +00002673 BuildCXXDefaultArgExpr(Call->getSourceRange().getBegin(),
2674 FDecl, Param);
2675 if (ArgExpr.isInvalid())
2676 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00002677
Anders Carlsson56c5e332009-08-25 03:49:14 +00002678 Arg = ArgExpr.takeAs<Expr>();
Anders Carlsson5e300d12009-06-12 16:51:40 +00002679 }
Mike Stump1eb44332009-09-09 15:08:12 +00002680
Douglas Gregor88a35142008-12-22 05:46:06 +00002681 Call->setArg(i, Arg);
2682 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00002683
Douglas Gregor88a35142008-12-22 05:46:06 +00002684 // If this is a variadic call, handle args passed through "...".
2685 if (Proto->isVariadic()) {
Anders Carlssondce5e2c2009-01-16 16:48:51 +00002686 VariadicCallType CallType = VariadicFunction;
2687 if (Fn->getType()->isBlockPointerType())
2688 CallType = VariadicBlock; // Block
2689 else if (isa<MemberExpr>(Fn))
2690 CallType = VariadicMethod;
2691
Douglas Gregor88a35142008-12-22 05:46:06 +00002692 // Promote the arguments (C99 6.5.2.2p7).
2693 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
2694 Expr *Arg = Args[i];
Chris Lattner312531a2009-04-12 08:11:20 +00002695 Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType);
Douglas Gregor88a35142008-12-22 05:46:06 +00002696 Call->setArg(i, Arg);
2697 }
2698 }
2699
Douglas Gregor3fd56d72009-01-23 21:30:56 +00002700 return Invalid;
Douglas Gregor88a35142008-12-22 05:46:06 +00002701}
2702
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00002703/// \brief "Deconstruct" the function argument of a call expression to find
2704/// the underlying declaration (if any), the name of the called function,
2705/// whether argument-dependent lookup is available, whether it has explicit
2706/// template arguments, etc.
2707void Sema::DeconstructCallFunction(Expr *FnExpr,
2708 NamedDecl *&Function,
2709 DeclarationName &Name,
2710 NestedNameSpecifier *&Qualifier,
2711 SourceRange &QualifierRange,
2712 bool &ArgumentDependentLookup,
2713 bool &HasExplicitTemplateArguments,
2714 const TemplateArgument *&ExplicitTemplateArgs,
2715 unsigned &NumExplicitTemplateArgs) {
2716 // Set defaults for all of the output parameters.
2717 Function = 0;
2718 Name = DeclarationName();
2719 Qualifier = 0;
2720 QualifierRange = SourceRange();
2721 ArgumentDependentLookup = getLangOptions().CPlusPlus;
2722 HasExplicitTemplateArguments = false;
2723
2724 // If we're directly calling a function, get the appropriate declaration.
2725 // Also, in C++, keep track of whether we should perform argument-dependent
2726 // lookup and whether there were any explicitly-specified template arguments.
2727 while (true) {
2728 if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(FnExpr))
2729 FnExpr = IcExpr->getSubExpr();
2730 else if (ParenExpr *PExpr = dyn_cast<ParenExpr>(FnExpr)) {
2731 // Parentheses around a function disable ADL
2732 // (C++0x [basic.lookup.argdep]p1).
2733 ArgumentDependentLookup = false;
2734 FnExpr = PExpr->getSubExpr();
2735 } else if (isa<UnaryOperator>(FnExpr) &&
2736 cast<UnaryOperator>(FnExpr)->getOpcode()
2737 == UnaryOperator::AddrOf) {
2738 FnExpr = cast<UnaryOperator>(FnExpr)->getSubExpr();
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00002739 } else if (DeclRefExpr *DRExpr = dyn_cast<DeclRefExpr>(FnExpr)) {
2740 Function = dyn_cast<NamedDecl>(DRExpr->getDecl());
Douglas Gregora2813ce2009-10-23 18:54:35 +00002741 if ((Qualifier = DRExpr->getQualifier())) {
2742 ArgumentDependentLookup = false;
2743 QualifierRange = DRExpr->getQualifierRange();
2744 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00002745 break;
2746 } else if (UnresolvedFunctionNameExpr *DepName
2747 = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) {
2748 Name = DepName->getName();
2749 break;
2750 } else if (TemplateIdRefExpr *TemplateIdRef
2751 = dyn_cast<TemplateIdRefExpr>(FnExpr)) {
2752 Function = TemplateIdRef->getTemplateName().getAsTemplateDecl();
2753 if (!Function)
2754 Function = TemplateIdRef->getTemplateName().getAsOverloadedFunctionDecl();
2755 HasExplicitTemplateArguments = true;
2756 ExplicitTemplateArgs = TemplateIdRef->getTemplateArgs();
2757 NumExplicitTemplateArgs = TemplateIdRef->getNumTemplateArgs();
2758
2759 // C++ [temp.arg.explicit]p6:
2760 // [Note: For simple function names, argument dependent lookup (3.4.2)
2761 // applies even when the function name is not visible within the
2762 // scope of the call. This is because the call still has the syntactic
2763 // form of a function call (3.4.1). But when a function template with
2764 // explicit template arguments is used, the call does not have the
2765 // correct syntactic form unless there is a function template with
2766 // that name visible at the point of the call. If no such name is
2767 // visible, the call is not syntactically well-formed and
2768 // argument-dependent lookup does not apply. If some such name is
2769 // visible, argument dependent lookup applies and additional function
2770 // templates may be found in other namespaces.
2771 //
2772 // The summary of this paragraph is that, if we get to this point and the
2773 // template-id was not a qualified name, then argument-dependent lookup
2774 // is still possible.
2775 if ((Qualifier = TemplateIdRef->getQualifier())) {
2776 ArgumentDependentLookup = false;
2777 QualifierRange = TemplateIdRef->getQualifierRange();
2778 }
2779 break;
2780 } else {
2781 // Any kind of name that does not refer to a declaration (or
2782 // set of declarations) disables ADL (C++0x [basic.lookup.argdep]p3).
2783 ArgumentDependentLookup = false;
2784 break;
2785 }
2786 }
2787}
2788
Steve Narofff69936d2007-09-16 03:34:24 +00002789/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00002790/// This provides the location of the left/right parens and a list of comma
2791/// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00002792Action::OwningExprResult
2793Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc,
2794 MultiExprArg args,
Douglas Gregor88a35142008-12-22 05:46:06 +00002795 SourceLocation *CommaLocs, SourceLocation RParenLoc) {
Sebastian Redl0eb23302009-01-19 00:08:26 +00002796 unsigned NumArgs = args.size();
Nate Begeman2ef13e52009-08-10 23:49:36 +00002797
2798 // Since this might be a postfix expression, get rid of ParenListExprs.
2799 fn = MaybeConvertParenListExprToParenExpr(S, move(fn));
Mike Stump1eb44332009-09-09 15:08:12 +00002800
Anders Carlssonf1b1d592009-05-01 19:30:39 +00002801 Expr *Fn = fn.takeAs<Expr>();
Sebastian Redl0eb23302009-01-19 00:08:26 +00002802 Expr **Args = reinterpret_cast<Expr**>(args.release());
Chris Lattner74c469f2007-07-21 03:03:59 +00002803 assert(Fn && "no function call expression");
Chris Lattner04421082008-04-08 04:40:51 +00002804 FunctionDecl *FDecl = NULL;
Fariborz Jahaniandaf04152009-05-15 20:33:25 +00002805 NamedDecl *NDecl = NULL;
Douglas Gregor17330012009-02-04 15:01:18 +00002806 DeclarationName UnqualifiedName;
Mike Stump1eb44332009-09-09 15:08:12 +00002807
Douglas Gregor88a35142008-12-22 05:46:06 +00002808 if (getLangOptions().CPlusPlus) {
Douglas Gregora71d8192009-09-04 17:36:40 +00002809 // If this is a pseudo-destructor expression, build the call immediately.
2810 if (isa<CXXPseudoDestructorExpr>(Fn)) {
2811 if (NumArgs > 0) {
2812 // Pseudo-destructor calls should not have any arguments.
2813 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args)
2814 << CodeModificationHint::CreateRemoval(
2815 SourceRange(Args[0]->getLocStart(),
2816 Args[NumArgs-1]->getLocEnd()));
Mike Stump1eb44332009-09-09 15:08:12 +00002817
Douglas Gregora71d8192009-09-04 17:36:40 +00002818 for (unsigned I = 0; I != NumArgs; ++I)
2819 Args[I]->Destroy(Context);
Mike Stump1eb44332009-09-09 15:08:12 +00002820
Douglas Gregora71d8192009-09-04 17:36:40 +00002821 NumArgs = 0;
2822 }
Mike Stump1eb44332009-09-09 15:08:12 +00002823
Douglas Gregora71d8192009-09-04 17:36:40 +00002824 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy,
2825 RParenLoc));
2826 }
Mike Stump1eb44332009-09-09 15:08:12 +00002827
Douglas Gregor17330012009-02-04 15:01:18 +00002828 // Determine whether this is a dependent call inside a C++ template,
Mike Stumpeed9cac2009-02-19 03:04:26 +00002829 // in which case we won't do any semantic analysis now.
Mike Stump390b4cc2009-05-16 07:39:55 +00002830 // FIXME: Will need to cache the results of name lookup (including ADL) in
2831 // Fn.
Douglas Gregor17330012009-02-04 15:01:18 +00002832 bool Dependent = false;
2833 if (Fn->isTypeDependent())
2834 Dependent = true;
2835 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs))
2836 Dependent = true;
2837
2838 if (Dependent)
Ted Kremenek668bf912009-02-09 20:51:47 +00002839 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs,
Douglas Gregor17330012009-02-04 15:01:18 +00002840 Context.DependentTy, RParenLoc));
2841
2842 // Determine whether this is a call to an object (C++ [over.call.object]).
2843 if (Fn->getType()->isRecordType())
2844 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs,
2845 CommaLocs, RParenLoc));
2846
Douglas Gregorfa047642009-02-04 00:32:51 +00002847 // Determine whether this is a call to a member function.
Douglas Gregore53060f2009-06-25 22:08:12 +00002848 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(Fn->IgnoreParens())) {
2849 NamedDecl *MemDecl = MemExpr->getMemberDecl();
2850 if (isa<OverloadedFunctionDecl>(MemDecl) ||
2851 isa<CXXMethodDecl>(MemDecl) ||
2852 (isa<FunctionTemplateDecl>(MemDecl) &&
2853 isa<CXXMethodDecl>(
2854 cast<FunctionTemplateDecl>(MemDecl)->getTemplatedDecl())))
Sebastian Redl0eb23302009-01-19 00:08:26 +00002855 return Owned(BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
2856 CommaLocs, RParenLoc));
Douglas Gregore53060f2009-06-25 22:08:12 +00002857 }
Anders Carlsson83ccfc32009-10-03 17:40:22 +00002858
2859 // Determine whether this is a call to a pointer-to-member function.
2860 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Fn->IgnoreParens())) {
2861 if (BO->getOpcode() == BinaryOperator::PtrMemD ||
2862 BO->getOpcode() == BinaryOperator::PtrMemI) {
2863 const FunctionProtoType *FPT = cast<FunctionProtoType>(BO->getType());
Anders Carlsson8d6d90d2009-10-15 00:41:48 +00002864 QualType ResultTy = FPT->getResultType().getNonReferenceType();
Anders Carlsson83ccfc32009-10-03 17:40:22 +00002865
Anders Carlsson8d6d90d2009-10-15 00:41:48 +00002866 ExprOwningPtr<CXXMemberCallExpr>
2867 TheCall(this, new (Context) CXXMemberCallExpr(Context, BO, Args,
2868 NumArgs, ResultTy,
2869 RParenLoc));
Anders Carlsson83ccfc32009-10-03 17:40:22 +00002870
Anders Carlsson8d6d90d2009-10-15 00:41:48 +00002871 if (CheckCallReturnType(FPT->getResultType(),
2872 BO->getRHS()->getSourceRange().getBegin(),
2873 TheCall.get(), 0))
2874 return ExprError();
2875
Anders Carlsson83ccfc32009-10-03 17:40:22 +00002876 if (ConvertArgumentsForCall(&*TheCall, BO, 0, FPT, Args, NumArgs,
2877 RParenLoc))
2878 return ExprError();
2879
2880 return Owned(MaybeBindToTemporary(TheCall.release()).release());
2881 }
2882 }
Douglas Gregor88a35142008-12-22 05:46:06 +00002883 }
2884
Douglas Gregorfa047642009-02-04 00:32:51 +00002885 // If we're directly calling a function, get the appropriate declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00002886 // Also, in C++, keep track of whether we should perform argument-dependent
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002887 // lookup and whether there were any explicitly-specified template arguments.
Douglas Gregorfa047642009-02-04 00:32:51 +00002888 bool ADL = true;
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002889 bool HasExplicitTemplateArgs = 0;
2890 const TemplateArgument *ExplicitTemplateArgs = 0;
2891 unsigned NumExplicitTemplateArgs = 0;
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00002892 NestedNameSpecifier *Qualifier = 0;
2893 SourceRange QualifierRange;
2894 DeconstructCallFunction(Fn, NDecl, UnqualifiedName, Qualifier, QualifierRange,
2895 ADL,HasExplicitTemplateArgs, ExplicitTemplateArgs,
2896 NumExplicitTemplateArgs);
Mike Stumpeed9cac2009-02-19 03:04:26 +00002897
Douglas Gregor17330012009-02-04 15:01:18 +00002898 OverloadedFunctionDecl *Ovl = 0;
Douglas Gregore53060f2009-06-25 22:08:12 +00002899 FunctionTemplateDecl *FunctionTemplate = 0;
Douglas Gregoredce4dd2009-06-30 22:34:41 +00002900 if (NDecl) {
2901 FDecl = dyn_cast<FunctionDecl>(NDecl);
2902 if ((FunctionTemplate = dyn_cast<FunctionTemplateDecl>(NDecl)))
Douglas Gregore53060f2009-06-25 22:08:12 +00002903 FDecl = FunctionTemplate->getTemplatedDecl();
2904 else
Douglas Gregoredce4dd2009-06-30 22:34:41 +00002905 FDecl = dyn_cast<FunctionDecl>(NDecl);
2906 Ovl = dyn_cast<OverloadedFunctionDecl>(NDecl);
Douglas Gregor17330012009-02-04 15:01:18 +00002907 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00002908
Mike Stump1eb44332009-09-09 15:08:12 +00002909 if (Ovl || FunctionTemplate ||
Douglas Gregore53060f2009-06-25 22:08:12 +00002910 (getLangOptions().CPlusPlus && (FDecl || UnqualifiedName))) {
Douglas Gregor3e41d602009-02-13 23:20:09 +00002911 // We don't perform ADL for implicit declarations of builtins.
Douglas Gregor7814e6d2009-09-12 00:22:50 +00002912 if (FDecl && FDecl->getBuiltinID() && FDecl->isImplicit())
Douglas Gregorfa047642009-02-04 00:32:51 +00002913 ADL = false;
2914
Douglas Gregorf9201e02009-02-11 23:02:49 +00002915 // We don't perform ADL in C.
2916 if (!getLangOptions().CPlusPlus)
2917 ADL = false;
2918
Douglas Gregore53060f2009-06-25 22:08:12 +00002919 if (Ovl || FunctionTemplate || ADL) {
Mike Stump1eb44332009-09-09 15:08:12 +00002920 FDecl = ResolveOverloadedCallFn(Fn, NDecl, UnqualifiedName,
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002921 HasExplicitTemplateArgs,
2922 ExplicitTemplateArgs,
2923 NumExplicitTemplateArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00002924 LParenLoc, Args, NumArgs, CommaLocs,
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002925 RParenLoc, ADL);
Douglas Gregorfa047642009-02-04 00:32:51 +00002926 if (!FDecl)
2927 return ExprError();
2928
Douglas Gregor097bfb12009-10-23 22:18:25 +00002929 Fn = FixOverloadedFunctionReference(Fn, FDecl);
Douglas Gregorfa047642009-02-04 00:32:51 +00002930 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00002931 }
Chris Lattner04421082008-04-08 04:40:51 +00002932
2933 // Promote the function operand.
2934 UsualUnaryConversions(Fn);
2935
Chris Lattner925e60d2007-12-28 05:29:59 +00002936 // Make the call expr early, before semantic checks. This guarantees cleanup
2937 // of arguments and function on error.
Ted Kremenek668bf912009-02-09 20:51:47 +00002938 ExprOwningPtr<CallExpr> TheCall(this, new (Context) CallExpr(Context, Fn,
2939 Args, NumArgs,
2940 Context.BoolTy,
2941 RParenLoc));
Sebastian Redl0eb23302009-01-19 00:08:26 +00002942
Steve Naroffdd972f22008-09-05 22:11:13 +00002943 const FunctionType *FuncT;
2944 if (!Fn->getType()->isBlockPointerType()) {
2945 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
2946 // have type pointer to function".
Ted Kremenek6217b802009-07-29 21:53:49 +00002947 const PointerType *PT = Fn->getType()->getAs<PointerType>();
Steve Naroffdd972f22008-09-05 22:11:13 +00002948 if (PT == 0)
Sebastian Redl0eb23302009-01-19 00:08:26 +00002949 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2950 << Fn->getType() << Fn->getSourceRange());
John McCall183700f2009-09-21 23:43:11 +00002951 FuncT = PT->getPointeeType()->getAs<FunctionType>();
Steve Naroffdd972f22008-09-05 22:11:13 +00002952 } else { // This is a block call.
Ted Kremenek6217b802009-07-29 21:53:49 +00002953 FuncT = Fn->getType()->getAs<BlockPointerType>()->getPointeeType()->
John McCall183700f2009-09-21 23:43:11 +00002954 getAs<FunctionType>();
Steve Naroffdd972f22008-09-05 22:11:13 +00002955 }
Chris Lattner925e60d2007-12-28 05:29:59 +00002956 if (FuncT == 0)
Sebastian Redl0eb23302009-01-19 00:08:26 +00002957 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2958 << Fn->getType() << Fn->getSourceRange());
2959
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002960 // Check for a valid return type
Anders Carlsson8c8d9192009-10-09 23:51:55 +00002961 if (CheckCallReturnType(FuncT->getResultType(),
2962 Fn->getSourceRange().getBegin(), TheCall.get(),
2963 FDecl))
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002964 return ExprError();
2965
Chris Lattner925e60d2007-12-28 05:29:59 +00002966 // We know the result type of the call, set it.
Douglas Gregor15da57e2008-10-29 02:00:59 +00002967 TheCall->setType(FuncT->getResultType().getNonReferenceType());
Sebastian Redl0eb23302009-01-19 00:08:26 +00002968
Douglas Gregor72564e72009-02-26 23:50:07 +00002969 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
Mike Stumpeed9cac2009-02-19 03:04:26 +00002970 if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
Douglas Gregor88a35142008-12-22 05:46:06 +00002971 RParenLoc))
Sebastian Redl0eb23302009-01-19 00:08:26 +00002972 return ExprError();
Chris Lattner925e60d2007-12-28 05:29:59 +00002973 } else {
Douglas Gregor72564e72009-02-26 23:50:07 +00002974 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
Sebastian Redl0eb23302009-01-19 00:08:26 +00002975
Douglas Gregor74734d52009-04-02 15:37:10 +00002976 if (FDecl) {
2977 // Check if we have too few/too many template arguments, based
2978 // on our knowledge of the function definition.
2979 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00002980 if (FDecl->getBody(Def) && NumArgs != Def->param_size()) {
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00002981 const FunctionProtoType *Proto =
John McCall183700f2009-09-21 23:43:11 +00002982 Def->getType()->getAs<FunctionProtoType>();
Eli Friedmanbc4e29f2009-06-01 09:24:59 +00002983 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) {
2984 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
2985 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange();
2986 }
2987 }
Douglas Gregor74734d52009-04-02 15:37:10 +00002988 }
2989
Steve Naroffb291ab62007-08-28 23:30:39 +00002990 // Promote the arguments (C99 6.5.2.2p6).
Chris Lattner925e60d2007-12-28 05:29:59 +00002991 for (unsigned i = 0; i != NumArgs; i++) {
2992 Expr *Arg = Args[i];
2993 DefaultArgumentPromotion(Arg);
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002994 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2995 Arg->getType(),
Anders Carlssonb7906612009-08-26 23:45:07 +00002996 PDiag(diag::err_call_incomplete_argument)
2997 << Arg->getSourceRange()))
Eli Friedmane7c6f7a2009-03-22 22:00:50 +00002998 return ExprError();
Chris Lattner925e60d2007-12-28 05:29:59 +00002999 TheCall->setArg(i, Arg);
Steve Naroffb291ab62007-08-28 23:30:39 +00003000 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003001 }
Chris Lattner925e60d2007-12-28 05:29:59 +00003002
Douglas Gregor88a35142008-12-22 05:46:06 +00003003 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
3004 if (!Method->isStatic())
Sebastian Redl0eb23302009-01-19 00:08:26 +00003005 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
3006 << Fn->getSourceRange());
Douglas Gregor88a35142008-12-22 05:46:06 +00003007
Fariborz Jahaniandaf04152009-05-15 20:33:25 +00003008 // Check for sentinels
3009 if (NDecl)
3010 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003011
Chris Lattner59907c42007-08-10 20:18:51 +00003012 // Do special checking on direct calls to functions.
Anders Carlssond406bf02009-08-16 01:56:34 +00003013 if (FDecl) {
3014 if (CheckFunctionCall(FDecl, TheCall.get()))
3015 return ExprError();
Mike Stump1eb44332009-09-09 15:08:12 +00003016
Douglas Gregor7814e6d2009-09-12 00:22:50 +00003017 if (unsigned BuiltinID = FDecl->getBuiltinID())
Anders Carlssond406bf02009-08-16 01:56:34 +00003018 return CheckBuiltinFunctionCall(BuiltinID, TheCall.take());
3019 } else if (NDecl) {
3020 if (CheckBlockCall(NDecl, TheCall.get()))
3021 return ExprError();
3022 }
Chris Lattner59907c42007-08-10 20:18:51 +00003023
Anders Carlssonec74c592009-08-16 03:06:32 +00003024 return MaybeBindToTemporary(TheCall.take());
Reid Spencer5f016e22007-07-11 17:01:13 +00003025}
3026
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003027Action::OwningExprResult
3028Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
3029 SourceLocation RParenLoc, ExprArg InitExpr) {
Steve Narofff69936d2007-09-16 03:34:24 +00003030 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00003031 //FIXME: Preserve type source info.
3032 QualType literalType = GetTypeFromParser(Ty);
Steve Naroffaff1edd2007-07-19 21:32:11 +00003033 // FIXME: put back this assert when initializers are worked out.
Steve Narofff69936d2007-09-16 03:34:24 +00003034 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003035 Expr *literalExpr = static_cast<Expr*>(InitExpr.get());
Anders Carlssond35c8322007-12-05 07:24:19 +00003036
Eli Friedman6223c222008-05-20 05:22:08 +00003037 if (literalType->isArrayType()) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00003038 if (literalType->isVariableArrayType())
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003039 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
3040 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()));
Douglas Gregor690dc7f2009-05-21 23:48:18 +00003041 } else if (!literalType->isDependentType() &&
3042 RequireCompleteType(LParenLoc, literalType,
Anders Carlssonb7906612009-08-26 23:45:07 +00003043 PDiag(diag::err_typecheck_decl_incomplete_type)
Mike Stump1eb44332009-09-09 15:08:12 +00003044 << SourceRange(LParenLoc,
Anders Carlssonb7906612009-08-26 23:45:07 +00003045 literalExpr->getSourceRange().getEnd())))
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003046 return ExprError();
Eli Friedman6223c222008-05-20 05:22:08 +00003047
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003048 if (CheckInitializerTypes(literalExpr, literalType, LParenLoc,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003049 DeclarationName(), /*FIXME:DirectInit=*/false))
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003050 return ExprError();
Steve Naroffe9b12192008-01-14 18:19:28 +00003051
Chris Lattner371f2582008-12-04 23:50:19 +00003052 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
Steve Naroffe9b12192008-01-14 18:19:28 +00003053 if (isFileScope) { // 6.5.2.5p3
Steve Naroffd0091aa2008-01-10 22:15:12 +00003054 if (CheckForConstantInitializer(literalExpr, literalType))
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003055 return ExprError();
Steve Naroffd0091aa2008-01-10 22:15:12 +00003056 }
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003057 InitExpr.release();
Mike Stumpeed9cac2009-02-19 03:04:26 +00003058 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, literalType,
Steve Naroff6ece14c2009-01-21 00:14:39 +00003059 literalExpr, isFileScope));
Steve Naroff4aa88f82007-07-19 01:06:55 +00003060}
3061
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003062Action::OwningExprResult
3063Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003064 SourceLocation RBraceLoc) {
3065 unsigned NumInit = initlist.size();
3066 Expr **InitList = reinterpret_cast<Expr**>(initlist.release());
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00003067
Steve Naroff08d92e42007-09-15 18:49:24 +00003068 // Semantic analysis for initializers is done by ActOnDeclarator() and
Mike Stumpeed9cac2009-02-19 03:04:26 +00003069 // CheckInitializer() - it requires knowledge of the object being intialized.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003070
Mike Stumpeed9cac2009-02-19 03:04:26 +00003071 InitListExpr *E = new (Context) InitListExpr(LBraceLoc, InitList, NumInit,
Douglas Gregor4c678342009-01-28 21:54:33 +00003072 RBraceLoc);
Chris Lattnerf0467b32008-04-02 04:24:33 +00003073 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003074 return Owned(E);
Steve Naroff4aa88f82007-07-19 01:06:55 +00003075}
3076
Anders Carlsson82debc72009-10-18 18:12:03 +00003077static CastExpr::CastKind getScalarCastKind(ASTContext &Context,
3078 QualType SrcTy, QualType DestTy) {
3079 if (Context.getCanonicalType(SrcTy).getUnqualifiedType() ==
3080 Context.getCanonicalType(DestTy).getUnqualifiedType())
3081 return CastExpr::CK_NoOp;
3082
3083 if (SrcTy->hasPointerRepresentation()) {
3084 if (DestTy->hasPointerRepresentation())
3085 return CastExpr::CK_BitCast;
3086 if (DestTy->isIntegerType())
3087 return CastExpr::CK_PointerToIntegral;
3088 }
3089
3090 if (SrcTy->isIntegerType()) {
3091 if (DestTy->isIntegerType())
3092 return CastExpr::CK_IntegralCast;
3093 if (DestTy->hasPointerRepresentation())
3094 return CastExpr::CK_IntegralToPointer;
3095 if (DestTy->isRealFloatingType())
3096 return CastExpr::CK_IntegralToFloating;
3097 }
3098
3099 if (SrcTy->isRealFloatingType()) {
3100 if (DestTy->isRealFloatingType())
3101 return CastExpr::CK_FloatingCast;
3102 if (DestTy->isIntegerType())
3103 return CastExpr::CK_FloatingToIntegral;
3104 }
3105
3106 // FIXME: Assert here.
3107 // assert(false && "Unhandled cast combination!");
3108 return CastExpr::CK_Unknown;
3109}
3110
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003111/// CheckCastTypes - Check type constraints for casting between types.
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003112bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00003113 CastExpr::CastKind& Kind,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003114 CXXMethodDecl *& ConversionDecl,
3115 bool FunctionalStyle) {
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003116 if (getLangOptions().CPlusPlus)
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003117 return CXXCheckCStyleCast(TyR, castType, castExpr, Kind, FunctionalStyle,
3118 ConversionDecl);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003119
Eli Friedman199ea952009-08-15 19:02:19 +00003120 DefaultFunctionArrayConversion(castExpr);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003121
3122 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
3123 // type needs to be scalar.
3124 if (castType->isVoidType()) {
3125 // Cast to void allows any expr type.
Anders Carlssonebeaf202009-10-16 02:35:04 +00003126 Kind = CastExpr::CK_ToVoid;
3127 return false;
3128 }
3129
3130 if (!castType->isScalarType() && !castType->isVectorType()) {
Seo Sanghyeoneff2cd52009-01-15 04:51:39 +00003131 if (Context.getCanonicalType(castType).getUnqualifiedType() ==
3132 Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) &&
3133 (castType->isStructureType() || castType->isUnionType())) {
3134 // GCC struct/union extension: allow cast to self.
Eli Friedmanb1d796d2009-03-23 00:24:07 +00003135 // FIXME: Check that the cast destination type is complete.
Seo Sanghyeoneff2cd52009-01-15 04:51:39 +00003136 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar)
3137 << castType << castExpr->getSourceRange();
Anders Carlsson4d8673b2009-08-07 23:22:37 +00003138 Kind = CastExpr::CK_NoOp;
Anders Carlssonc3516322009-10-16 02:48:28 +00003139 return false;
3140 }
3141
3142 if (castType->isUnionType()) {
Seo Sanghyeoneff2cd52009-01-15 04:51:39 +00003143 // GCC cast to union extension
Ted Kremenek6217b802009-07-29 21:53:49 +00003144 RecordDecl *RD = castType->getAs<RecordType>()->getDecl();
Seo Sanghyeoneff2cd52009-01-15 04:51:39 +00003145 RecordDecl::field_iterator Field, FieldEnd;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003146 for (Field = RD->field_begin(), FieldEnd = RD->field_end();
Seo Sanghyeoneff2cd52009-01-15 04:51:39 +00003147 Field != FieldEnd; ++Field) {
3148 if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() ==
3149 Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) {
3150 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union)
3151 << castExpr->getSourceRange();
3152 break;
3153 }
3154 }
3155 if (Field == FieldEnd)
3156 return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type)
3157 << castExpr->getType() << castExpr->getSourceRange();
Anders Carlsson4d8673b2009-08-07 23:22:37 +00003158 Kind = CastExpr::CK_ToUnion;
Anders Carlssonc3516322009-10-16 02:48:28 +00003159 return false;
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003160 }
Anders Carlssonc3516322009-10-16 02:48:28 +00003161
3162 // Reject any other conversions to non-scalar types.
3163 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar)
3164 << castType << castExpr->getSourceRange();
3165 }
3166
3167 if (!castExpr->getType()->isScalarType() &&
3168 !castExpr->getType()->isVectorType()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00003169 return Diag(castExpr->getLocStart(),
3170 diag::err_typecheck_expect_scalar_operand)
Chris Lattnerd1625842008-11-24 06:25:27 +00003171 << castExpr->getType() << castExpr->getSourceRange();
Anders Carlssonc3516322009-10-16 02:48:28 +00003172 }
3173
Anders Carlsson16a89042009-10-16 05:23:41 +00003174 if (castType->isExtVectorType())
3175 return CheckExtVectorCast(TyR, castType, castExpr, Kind);
3176
Anders Carlssonc3516322009-10-16 02:48:28 +00003177 if (castType->isVectorType())
3178 return CheckVectorCast(TyR, castType, castExpr->getType(), Kind);
3179 if (castExpr->getType()->isVectorType())
3180 return CheckVectorCast(TyR, castExpr->getType(), castType, Kind);
3181
3182 if (getLangOptions().ObjC1 && isa<ObjCSuperExpr>(castExpr))
Steve Naroffa0c3e9c2009-04-08 23:52:26 +00003183 return Diag(castExpr->getLocStart(), diag::err_illegal_super_cast) << TyR;
Anders Carlssonc3516322009-10-16 02:48:28 +00003184
Anders Carlsson16a89042009-10-16 05:23:41 +00003185 if (isa<ObjCSelectorExpr>(castExpr))
3186 return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr);
3187
Anders Carlssonc3516322009-10-16 02:48:28 +00003188 if (!castType->isArithmeticType()) {
Eli Friedman41826bb2009-05-01 02:23:58 +00003189 QualType castExprType = castExpr->getType();
3190 if (!castExprType->isIntegralType() && castExprType->isArithmeticType())
3191 return Diag(castExpr->getLocStart(),
3192 diag::err_cast_pointer_from_non_pointer_int)
3193 << castExprType << castExpr->getSourceRange();
3194 } else if (!castExpr->getType()->isArithmeticType()) {
3195 if (!castType->isIntegralType() && castType->isArithmeticType())
3196 return Diag(castExpr->getLocStart(),
3197 diag::err_cast_pointer_to_non_pointer_int)
3198 << castType << castExpr->getSourceRange();
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003199 }
Anders Carlsson82debc72009-10-18 18:12:03 +00003200
3201 Kind = getScalarCastKind(Context, castExpr->getType(), castType);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003202 return false;
3203}
3204
Anders Carlssonc3516322009-10-16 02:48:28 +00003205bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
3206 CastExpr::CastKind &Kind) {
Anders Carlssona64db8f2007-11-27 05:51:55 +00003207 assert(VectorTy->isVectorType() && "Not a vector type!");
Mike Stumpeed9cac2009-02-19 03:04:26 +00003208
Anders Carlssona64db8f2007-11-27 05:51:55 +00003209 if (Ty->isVectorType() || Ty->isIntegerType()) {
Chris Lattner98be4942008-03-05 18:54:05 +00003210 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
Anders Carlssona64db8f2007-11-27 05:51:55 +00003211 return Diag(R.getBegin(),
Mike Stumpeed9cac2009-02-19 03:04:26 +00003212 Ty->isVectorType() ?
Anders Carlssona64db8f2007-11-27 05:51:55 +00003213 diag::err_invalid_conversion_between_vectors :
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00003214 diag::err_invalid_conversion_between_vector_and_integer)
Chris Lattnerd1625842008-11-24 06:25:27 +00003215 << VectorTy << Ty << R;
Anders Carlssona64db8f2007-11-27 05:51:55 +00003216 } else
3217 return Diag(R.getBegin(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00003218 diag::err_invalid_conversion_between_vector_and_scalar)
Chris Lattnerd1625842008-11-24 06:25:27 +00003219 << VectorTy << Ty << R;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003220
Anders Carlssonc3516322009-10-16 02:48:28 +00003221 Kind = CastExpr::CK_BitCast;
Anders Carlssona64db8f2007-11-27 05:51:55 +00003222 return false;
3223}
3224
Anders Carlsson16a89042009-10-16 05:23:41 +00003225bool Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *&CastExpr,
3226 CastExpr::CastKind &Kind) {
Nate Begeman58d29a42009-06-26 00:50:28 +00003227 assert(DestTy->isExtVectorType() && "Not an extended vector type!");
Anders Carlsson16a89042009-10-16 05:23:41 +00003228
3229 QualType SrcTy = CastExpr->getType();
3230
Nate Begeman9b10da62009-06-27 22:05:55 +00003231 // If SrcTy is a VectorType, the total size must match to explicitly cast to
3232 // an ExtVectorType.
Nate Begeman58d29a42009-06-26 00:50:28 +00003233 if (SrcTy->isVectorType()) {
3234 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy))
3235 return Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
3236 << DestTy << SrcTy << R;
Anders Carlsson16a89042009-10-16 05:23:41 +00003237 Kind = CastExpr::CK_BitCast;
Nate Begeman58d29a42009-06-26 00:50:28 +00003238 return false;
3239 }
3240
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00003241 // All non-pointer scalars can be cast to ExtVector type. The appropriate
Nate Begeman58d29a42009-06-26 00:50:28 +00003242 // conversion will take place first from scalar to elt type, and then
3243 // splat from elt type to vector.
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00003244 if (SrcTy->isPointerType())
3245 return Diag(R.getBegin(),
3246 diag::err_invalid_conversion_between_vector_and_scalar)
3247 << DestTy << SrcTy << R;
Eli Friedman73c39ab2009-10-20 08:27:19 +00003248
3249 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType();
3250 ImpCastExprToType(CastExpr, DestElemTy,
3251 getScalarCastKind(Context, SrcTy, DestElemTy));
Anders Carlsson16a89042009-10-16 05:23:41 +00003252
3253 Kind = CastExpr::CK_VectorSplat;
Nate Begeman58d29a42009-06-26 00:50:28 +00003254 return false;
3255}
3256
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003257Action::OwningExprResult
Nate Begeman2ef13e52009-08-10 23:49:36 +00003258Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, TypeTy *Ty,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003259 SourceLocation RParenLoc, ExprArg Op) {
Anders Carlssoncdb61972009-08-07 22:21:05 +00003260 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
Mike Stump1eb44332009-09-09 15:08:12 +00003261
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003262 assert((Ty != 0) && (Op.get() != 0) &&
3263 "ActOnCastExpr(): missing type or expr");
Steve Naroff16beff82007-07-16 23:25:18 +00003264
Nate Begeman2ef13e52009-08-10 23:49:36 +00003265 Expr *castExpr = (Expr *)Op.get();
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00003266 //FIXME: Preserve type source info.
3267 QualType castType = GetTypeFromParser(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00003268
Nate Begeman2ef13e52009-08-10 23:49:36 +00003269 // If the Expr being casted is a ParenListExpr, handle it specially.
3270 if (isa<ParenListExpr>(castExpr))
3271 return ActOnCastOfParenListExpr(S, LParenLoc, RParenLoc, move(Op),castType);
Anders Carlsson0aebc812009-09-09 21:33:21 +00003272 CXXMethodDecl *Method = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003273 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr,
Anders Carlsson0aebc812009-09-09 21:33:21 +00003274 Kind, Method))
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003275 return ExprError();
Anders Carlsson0aebc812009-09-09 21:33:21 +00003276
3277 if (Method) {
Daniel Dunbar7e88a602009-09-17 06:31:17 +00003278 OwningExprResult CastArg = BuildCXXCastArgument(LParenLoc, castType, Kind,
Anders Carlsson0aebc812009-09-09 21:33:21 +00003279 Method, move(Op));
Daniel Dunbar7e88a602009-09-17 06:31:17 +00003280
Anders Carlsson0aebc812009-09-09 21:33:21 +00003281 if (CastArg.isInvalid())
3282 return ExprError();
Daniel Dunbar7e88a602009-09-17 06:31:17 +00003283
Anders Carlsson0aebc812009-09-09 21:33:21 +00003284 castExpr = CastArg.takeAs<Expr>();
3285 } else {
3286 Op.release();
Fariborz Jahanian31976592009-08-29 19:15:16 +00003287 }
Mike Stump1eb44332009-09-09 15:08:12 +00003288
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003289 return Owned(new (Context) CStyleCastExpr(castType.getNonReferenceType(),
Mike Stump1eb44332009-09-09 15:08:12 +00003290 Kind, castExpr, castType,
Anders Carlssoncdb61972009-08-07 22:21:05 +00003291 LParenLoc, RParenLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +00003292}
3293
Nate Begeman2ef13e52009-08-10 23:49:36 +00003294/// This is not an AltiVec-style cast, so turn the ParenListExpr into a sequence
3295/// of comma binary operators.
3296Action::OwningExprResult
3297Sema::MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg EA) {
3298 Expr *expr = EA.takeAs<Expr>();
3299 ParenListExpr *E = dyn_cast<ParenListExpr>(expr);
3300 if (!E)
3301 return Owned(expr);
Mike Stump1eb44332009-09-09 15:08:12 +00003302
Nate Begeman2ef13e52009-08-10 23:49:36 +00003303 OwningExprResult Result(*this, E->getExpr(0));
Mike Stump1eb44332009-09-09 15:08:12 +00003304
Nate Begeman2ef13e52009-08-10 23:49:36 +00003305 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
3306 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, move(Result),
3307 Owned(E->getExpr(i)));
Mike Stump1eb44332009-09-09 15:08:12 +00003308
Nate Begeman2ef13e52009-08-10 23:49:36 +00003309 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), move(Result));
3310}
3311
3312Action::OwningExprResult
3313Sema::ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
3314 SourceLocation RParenLoc, ExprArg Op,
3315 QualType Ty) {
3316 ParenListExpr *PE = (ParenListExpr *)Op.get();
Mike Stump1eb44332009-09-09 15:08:12 +00003317
3318 // If this is an altivec initializer, '(' type ')' '(' init, ..., init ')'
Nate Begeman2ef13e52009-08-10 23:49:36 +00003319 // then handle it as such.
3320 if (getLangOptions().AltiVec && Ty->isVectorType()) {
3321 if (PE->getNumExprs() == 0) {
3322 Diag(PE->getExprLoc(), diag::err_altivec_empty_initializer);
3323 return ExprError();
3324 }
3325
3326 llvm::SmallVector<Expr *, 8> initExprs;
3327 for (unsigned i = 0, e = PE->getNumExprs(); i != e; ++i)
3328 initExprs.push_back(PE->getExpr(i));
3329
3330 // FIXME: This means that pretty-printing the final AST will produce curly
3331 // braces instead of the original commas.
3332 Op.release();
Mike Stump1eb44332009-09-09 15:08:12 +00003333 InitListExpr *E = new (Context) InitListExpr(LParenLoc, &initExprs[0],
Nate Begeman2ef13e52009-08-10 23:49:36 +00003334 initExprs.size(), RParenLoc);
3335 E->setType(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00003336 return ActOnCompoundLiteral(LParenLoc, Ty.getAsOpaquePtr(), RParenLoc,
Nate Begeman2ef13e52009-08-10 23:49:36 +00003337 Owned(E));
3338 } else {
Mike Stump1eb44332009-09-09 15:08:12 +00003339 // This is not an AltiVec-style cast, so turn the ParenListExpr into a
Nate Begeman2ef13e52009-08-10 23:49:36 +00003340 // sequence of BinOp comma operators.
3341 Op = MaybeConvertParenListExprToParenExpr(S, move(Op));
3342 return ActOnCastExpr(S, LParenLoc, Ty.getAsOpaquePtr(), RParenLoc,move(Op));
3343 }
3344}
3345
3346Action::OwningExprResult Sema::ActOnParenListExpr(SourceLocation L,
3347 SourceLocation R,
3348 MultiExprArg Val) {
3349 unsigned nexprs = Val.size();
3350 Expr **exprs = reinterpret_cast<Expr**>(Val.release());
3351 assert((exprs != 0) && "ActOnParenListExpr() missing expr list");
3352 Expr *expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R);
3353 return Owned(expr);
3354}
3355
Sebastian Redl28507842009-02-26 14:39:58 +00003356/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension.
3357/// In that case, lhs = cond.
Chris Lattnera119a3b2009-02-18 04:38:20 +00003358/// C99 6.5.15
3359QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
3360 SourceLocation QuestionLoc) {
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003361 // C++ is sufficiently different to merit its own checker.
3362 if (getLangOptions().CPlusPlus)
3363 return CXXCheckConditionalOperands(Cond, LHS, RHS, QuestionLoc);
3364
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003365 UsualUnaryConversions(Cond);
3366 UsualUnaryConversions(LHS);
3367 UsualUnaryConversions(RHS);
3368 QualType CondTy = Cond->getType();
3369 QualType LHSTy = LHS->getType();
3370 QualType RHSTy = RHS->getType();
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003371
Reid Spencer5f016e22007-07-11 17:01:13 +00003372 // first, check the condition.
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003373 if (!CondTy->isScalarType()) { // C99 6.5.15p2
3374 Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar)
3375 << CondTy;
3376 return QualType();
Reid Spencer5f016e22007-07-11 17:01:13 +00003377 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00003378
Chris Lattner70d67a92008-01-06 22:42:25 +00003379 // Now check the two expressions.
Nate Begeman2ef13e52009-08-10 23:49:36 +00003380 if (LHSTy->isVectorType() || RHSTy->isVectorType())
3381 return CheckVectorOperands(QuestionLoc, LHS, RHS);
Douglas Gregor898574e2008-12-05 23:32:09 +00003382
Chris Lattner70d67a92008-01-06 22:42:25 +00003383 // If both operands have arithmetic type, do the usual arithmetic conversions
3384 // to find a common type: C99 6.5.15p3,5.
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003385 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
3386 UsualArithmeticConversions(LHS, RHS);
3387 return LHS->getType();
Steve Naroffa4332e22007-07-17 00:58:39 +00003388 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00003389
Chris Lattner70d67a92008-01-06 22:42:25 +00003390 // If both operands are the same structure or union type, the result is that
3391 // type.
Ted Kremenek6217b802009-07-29 21:53:49 +00003392 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3
3393 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
Chris Lattnera21ddb32007-11-26 01:40:58 +00003394 if (LHSRT->getDecl() == RHSRT->getDecl())
Mike Stumpeed9cac2009-02-19 03:04:26 +00003395 // "If both the operands have structure or union type, the result has
Chris Lattner70d67a92008-01-06 22:42:25 +00003396 // that type." This implies that CV qualifiers are dropped.
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003397 return LHSTy.getUnqualifiedType();
Eli Friedmanb1d796d2009-03-23 00:24:07 +00003398 // FIXME: Type of conditional expression must be complete in C mode.
Reid Spencer5f016e22007-07-11 17:01:13 +00003399 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00003400
Chris Lattner70d67a92008-01-06 22:42:25 +00003401 // C99 6.5.15p5: "If both operands have void type, the result has void type."
Steve Naroffe701c0a2008-05-12 21:44:38 +00003402 // The following || allows only one side to be void (a GCC-ism).
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003403 if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
3404 if (!LHSTy->isVoidType())
3405 Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3406 << RHS->getSourceRange();
3407 if (!RHSTy->isVoidType())
3408 Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3409 << LHS->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003410 ImpCastExprToType(LHS, Context.VoidTy, CastExpr::CK_ToVoid);
3411 ImpCastExprToType(RHS, Context.VoidTy, CastExpr::CK_ToVoid);
Eli Friedman0e724012008-06-04 19:47:51 +00003412 return Context.VoidTy;
Steve Naroffe701c0a2008-05-12 21:44:38 +00003413 }
Steve Naroffb6d54e52008-01-08 01:11:38 +00003414 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
3415 // the type of the other operand."
Steve Naroff58f9f2c2009-07-14 18:25:06 +00003416 if ((LHSTy->isAnyPointerType() || LHSTy->isBlockPointerType()) &&
Douglas Gregorce940492009-09-25 04:25:58 +00003417 RHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003418 // promote the null to a pointer.
3419 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_Unknown);
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003420 return LHSTy;
Steve Naroffb6d54e52008-01-08 01:11:38 +00003421 }
Steve Naroff58f9f2c2009-07-14 18:25:06 +00003422 if ((RHSTy->isAnyPointerType() || RHSTy->isBlockPointerType()) &&
Douglas Gregorce940492009-09-25 04:25:58 +00003423 LHS->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003424 ImpCastExprToType(LHS, RHSTy, CastExpr::CK_Unknown);
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003425 return RHSTy;
Steve Naroffb6d54e52008-01-08 01:11:38 +00003426 }
David Chisnall0f436562009-08-17 16:35:33 +00003427 // Handle things like Class and struct objc_class*. Here we case the result
3428 // to the pseudo-builtin, because that will be implicitly cast back to the
3429 // redefinition type if an attempt is made to access its fields.
3430 if (LHSTy->isObjCClassType() &&
3431 (RHSTy.getDesugaredType() == Context.ObjCClassRedefinitionType)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003432 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_BitCast);
David Chisnall0f436562009-08-17 16:35:33 +00003433 return LHSTy;
3434 }
3435 if (RHSTy->isObjCClassType() &&
3436 (LHSTy.getDesugaredType() == Context.ObjCClassRedefinitionType)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003437 ImpCastExprToType(LHS, RHSTy, CastExpr::CK_BitCast);
David Chisnall0f436562009-08-17 16:35:33 +00003438 return RHSTy;
3439 }
3440 // And the same for struct objc_object* / id
3441 if (LHSTy->isObjCIdType() &&
3442 (RHSTy.getDesugaredType() == Context.ObjCIdRedefinitionType)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003443 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_BitCast);
David Chisnall0f436562009-08-17 16:35:33 +00003444 return LHSTy;
3445 }
3446 if (RHSTy->isObjCIdType() &&
3447 (LHSTy.getDesugaredType() == Context.ObjCIdRedefinitionType)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00003448 ImpCastExprToType(LHS, RHSTy, CastExpr::CK_BitCast);
David Chisnall0f436562009-08-17 16:35:33 +00003449 return RHSTy;
3450 }
Steve Naroff7154a772009-07-01 14:36:47 +00003451 // Handle block pointer types.
3452 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
3453 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
3454 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
3455 QualType destType = Context.getPointerType(Context.VoidTy);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003456 ImpCastExprToType(LHS, destType, CastExpr::CK_BitCast);
3457 ImpCastExprToType(RHS, destType, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003458 return destType;
3459 }
3460 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3461 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3462 return QualType();
Mike Stumpdd3e1662009-05-07 03:14:14 +00003463 }
Steve Naroff7154a772009-07-01 14:36:47 +00003464 // We have 2 block pointer types.
3465 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3466 // Two identical block pointer types are always compatible.
Mike Stumpdd3e1662009-05-07 03:14:14 +00003467 return LHSTy;
3468 }
Steve Naroff7154a772009-07-01 14:36:47 +00003469 // The block pointer types aren't identical, continue checking.
Ted Kremenek6217b802009-07-29 21:53:49 +00003470 QualType lhptee = LHSTy->getAs<BlockPointerType>()->getPointeeType();
3471 QualType rhptee = RHSTy->getAs<BlockPointerType>()->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00003472
Steve Naroff7154a772009-07-01 14:36:47 +00003473 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3474 rhptee.getUnqualifiedType())) {
Mike Stumpdd3e1662009-05-07 03:14:14 +00003475 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3476 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3477 // In this situation, we assume void* type. No especially good
3478 // reason, but this is what gcc does, and we do have to pick
3479 // to get a consistent AST.
3480 QualType incompatTy = Context.getPointerType(Context.VoidTy);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003481 ImpCastExprToType(LHS, incompatTy, CastExpr::CK_BitCast);
3482 ImpCastExprToType(RHS, incompatTy, CastExpr::CK_BitCast);
Mike Stumpdd3e1662009-05-07 03:14:14 +00003483 return incompatTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00003484 }
Steve Naroff7154a772009-07-01 14:36:47 +00003485 // The block pointer types are compatible.
Eli Friedman73c39ab2009-10-20 08:27:19 +00003486 ImpCastExprToType(LHS, LHSTy, CastExpr::CK_BitCast);
3487 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_BitCast);
Steve Naroff91588042009-04-08 17:05:15 +00003488 return LHSTy;
3489 }
Steve Naroff7154a772009-07-01 14:36:47 +00003490 // Check constraints for Objective-C object pointers types.
Steve Naroff14108da2009-07-10 23:34:53 +00003491 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003492
Steve Naroff7154a772009-07-01 14:36:47 +00003493 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3494 // Two identical object pointer types are always compatible.
3495 return LHSTy;
3496 }
John McCall183700f2009-09-21 23:43:11 +00003497 const ObjCObjectPointerType *LHSOPT = LHSTy->getAs<ObjCObjectPointerType>();
3498 const ObjCObjectPointerType *RHSOPT = RHSTy->getAs<ObjCObjectPointerType>();
Steve Naroff7154a772009-07-01 14:36:47 +00003499 QualType compositeType = LHSTy;
Mike Stump1eb44332009-09-09 15:08:12 +00003500
Steve Naroff7154a772009-07-01 14:36:47 +00003501 // If both operands are interfaces and either operand can be
3502 // assigned to the other, use that type as the composite
3503 // type. This allows
3504 // xxx ? (A*) a : (B*) b
3505 // where B is a subclass of A.
3506 //
3507 // Additionally, as for assignment, if either type is 'id'
3508 // allow silent coercion. Finally, if the types are
3509 // incompatible then make sure to use 'id' as the composite
3510 // type so the result is acceptable for sending messages to.
3511
3512 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
3513 // It could return the composite type.
Steve Naroff14108da2009-07-10 23:34:53 +00003514 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
Fariborz Jahanian9ec22a32009-08-22 22:27:17 +00003515 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
Steve Naroff14108da2009-07-10 23:34:53 +00003516 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
Fariborz Jahanian9ec22a32009-08-22 22:27:17 +00003517 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
Mike Stump1eb44332009-09-09 15:08:12 +00003518 } else if ((LHSTy->isObjCQualifiedIdType() ||
Steve Naroff14108da2009-07-10 23:34:53 +00003519 RHSTy->isObjCQualifiedIdType()) &&
Steve Naroff4084c302009-07-23 01:01:38 +00003520 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) {
Mike Stump1eb44332009-09-09 15:08:12 +00003521 // Need to handle "id<xx>" explicitly.
Steve Naroff14108da2009-07-10 23:34:53 +00003522 // GCC allows qualified id and any Objective-C type to devolve to
3523 // id. Currently localizing to here until clear this should be
3524 // part of ObjCQualifiedIdTypesAreCompatible.
3525 compositeType = Context.getObjCIdType();
3526 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
Steve Naroff7154a772009-07-01 14:36:47 +00003527 compositeType = Context.getObjCIdType();
3528 } else {
3529 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
3530 << LHSTy << RHSTy
3531 << LHS->getSourceRange() << RHS->getSourceRange();
3532 QualType incompatTy = Context.getObjCIdType();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003533 ImpCastExprToType(LHS, incompatTy, CastExpr::CK_BitCast);
3534 ImpCastExprToType(RHS, incompatTy, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003535 return incompatTy;
3536 }
3537 // The object pointer types are compatible.
Eli Friedman73c39ab2009-10-20 08:27:19 +00003538 ImpCastExprToType(LHS, compositeType, CastExpr::CK_BitCast);
3539 ImpCastExprToType(RHS, compositeType, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003540 return compositeType;
3541 }
Steve Naroffc715e782009-07-29 15:09:39 +00003542 // Check Objective-C object pointer types and 'void *'
3543 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00003544 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
John McCall183700f2009-09-21 23:43:11 +00003545 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00003546 QualType destPointee
3547 = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
Steve Naroffc715e782009-07-29 15:09:39 +00003548 QualType destType = Context.getPointerType(destPointee);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003549 // Add qualifiers if necessary.
3550 ImpCastExprToType(LHS, destType, CastExpr::CK_NoOp);
3551 // Promote to void*.
3552 ImpCastExprToType(RHS, destType, CastExpr::CK_BitCast);
Steve Naroffc715e782009-07-29 15:09:39 +00003553 return destType;
3554 }
3555 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
John McCall183700f2009-09-21 23:43:11 +00003556 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003557 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00003558 QualType destPointee
3559 = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
Steve Naroffc715e782009-07-29 15:09:39 +00003560 QualType destType = Context.getPointerType(destPointee);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003561 // Add qualifiers if necessary.
3562 ImpCastExprToType(RHS, destType, CastExpr::CK_NoOp);
3563 // Promote to void*.
3564 ImpCastExprToType(LHS, destType, CastExpr::CK_BitCast);
Steve Naroffc715e782009-07-29 15:09:39 +00003565 return destType;
3566 }
Steve Naroff7154a772009-07-01 14:36:47 +00003567 // Check constraints for C object pointers types (C99 6.5.15p3,6).
3568 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
3569 // get the "pointed to" types
Ted Kremenek6217b802009-07-29 21:53:49 +00003570 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
3571 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
Steve Naroff7154a772009-07-01 14:36:47 +00003572
3573 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
3574 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
3575 // Figure out necessary qualifiers (C99 6.5.15p6)
John McCall0953e762009-09-24 19:53:00 +00003576 QualType destPointee
3577 = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
Steve Naroff7154a772009-07-01 14:36:47 +00003578 QualType destType = Context.getPointerType(destPointee);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003579 // Add qualifiers if necessary.
3580 ImpCastExprToType(LHS, destType, CastExpr::CK_NoOp);
3581 // Promote to void*.
3582 ImpCastExprToType(RHS, destType, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003583 return destType;
3584 }
3585 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
John McCall0953e762009-09-24 19:53:00 +00003586 QualType destPointee
3587 = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
Steve Naroff7154a772009-07-01 14:36:47 +00003588 QualType destType = Context.getPointerType(destPointee);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003589 // Add qualifiers if necessary.
3590 ImpCastExprToType(LHS, destType, CastExpr::CK_NoOp);
3591 // Promote to void*.
3592 ImpCastExprToType(RHS, destType, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003593 return destType;
3594 }
3595
3596 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3597 // Two identical pointer types are always compatible.
3598 return LHSTy;
3599 }
3600 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3601 rhptee.getUnqualifiedType())) {
3602 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3603 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3604 // In this situation, we assume void* type. No especially good
3605 // reason, but this is what gcc does, and we do have to pick
3606 // to get a consistent AST.
3607 QualType incompatTy = Context.getPointerType(Context.VoidTy);
Eli Friedman73c39ab2009-10-20 08:27:19 +00003608 ImpCastExprToType(LHS, incompatTy, CastExpr::CK_BitCast);
3609 ImpCastExprToType(RHS, incompatTy, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003610 return incompatTy;
3611 }
3612 // The pointer types are compatible.
3613 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
3614 // differently qualified versions of compatible types, the result type is
3615 // a pointer to an appropriately qualified version of the *composite*
3616 // type.
3617 // FIXME: Need to calculate the composite type.
3618 // FIXME: Need to add qualifiers
Eli Friedman73c39ab2009-10-20 08:27:19 +00003619 ImpCastExprToType(LHS, LHSTy, CastExpr::CK_BitCast);
3620 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_BitCast);
Steve Naroff7154a772009-07-01 14:36:47 +00003621 return LHSTy;
3622 }
Mike Stump1eb44332009-09-09 15:08:12 +00003623
Steve Naroff7154a772009-07-01 14:36:47 +00003624 // GCC compatibility: soften pointer/integer mismatch.
3625 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) {
3626 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3627 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003628 ImpCastExprToType(LHS, RHSTy, CastExpr::CK_IntegralToPointer);
Steve Naroff7154a772009-07-01 14:36:47 +00003629 return RHSTy;
3630 }
3631 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) {
3632 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3633 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00003634 ImpCastExprToType(RHS, LHSTy, CastExpr::CK_IntegralToPointer);
Steve Naroff7154a772009-07-01 14:36:47 +00003635 return LHSTy;
3636 }
Daniel Dunbar5e155f02008-09-11 23:12:46 +00003637
Chris Lattner70d67a92008-01-06 22:42:25 +00003638 // Otherwise, the operands are not compatible.
Chris Lattnerefdc39d2009-02-18 04:28:32 +00003639 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3640 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00003641 return QualType();
3642}
3643
Steve Narofff69936d2007-09-16 03:34:24 +00003644/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00003645/// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003646Action::OwningExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
3647 SourceLocation ColonLoc,
3648 ExprArg Cond, ExprArg LHS,
3649 ExprArg RHS) {
3650 Expr *CondExpr = (Expr *) Cond.get();
3651 Expr *LHSExpr = (Expr *) LHS.get(), *RHSExpr = (Expr *) RHS.get();
Chris Lattnera21ddb32007-11-26 01:40:58 +00003652
3653 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
3654 // was the condition.
3655 bool isLHSNull = LHSExpr == 0;
3656 if (isLHSNull)
3657 LHSExpr = CondExpr;
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003658
3659 QualType result = CheckConditionalOperands(CondExpr, LHSExpr,
Chris Lattner26824902007-07-16 21:39:03 +00003660 RHSExpr, QuestionLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003661 if (result.isNull())
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00003662 return ExprError();
3663
3664 Cond.release();
3665 LHS.release();
3666 RHS.release();
Douglas Gregor47e1f7c2009-08-26 14:37:04 +00003667 return Owned(new (Context) ConditionalOperator(CondExpr, QuestionLoc,
Steve Naroff6ece14c2009-01-21 00:14:39 +00003668 isLHSNull ? 0 : LHSExpr,
Douglas Gregor47e1f7c2009-08-26 14:37:04 +00003669 ColonLoc, RHSExpr, result));
Reid Spencer5f016e22007-07-11 17:01:13 +00003670}
3671
Reid Spencer5f016e22007-07-11 17:01:13 +00003672// CheckPointerTypesForAssignment - This is a very tricky routine (despite
Mike Stumpeed9cac2009-02-19 03:04:26 +00003673// being closely modeled after the C99 spec:-). The odd characteristic of this
Reid Spencer5f016e22007-07-11 17:01:13 +00003674// routine is it effectively iqnores the qualifiers on the top level pointee.
3675// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
3676// FIXME: add a couple examples in this comment.
Mike Stumpeed9cac2009-02-19 03:04:26 +00003677Sema::AssignConvertType
Reid Spencer5f016e22007-07-11 17:01:13 +00003678Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
3679 QualType lhptee, rhptee;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003680
David Chisnall0f436562009-08-17 16:35:33 +00003681 if ((lhsType->isObjCClassType() &&
3682 (rhsType.getDesugaredType() == Context.ObjCClassRedefinitionType)) ||
3683 (rhsType->isObjCClassType() &&
3684 (lhsType.getDesugaredType() == Context.ObjCClassRedefinitionType))) {
3685 return Compatible;
3686 }
3687
Reid Spencer5f016e22007-07-11 17:01:13 +00003688 // get the "pointed to" type (ignoring qualifiers at the top level)
Ted Kremenek6217b802009-07-29 21:53:49 +00003689 lhptee = lhsType->getAs<PointerType>()->getPointeeType();
3690 rhptee = rhsType->getAs<PointerType>()->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00003691
Reid Spencer5f016e22007-07-11 17:01:13 +00003692 // make sure we operate on the canonical type
Chris Lattnerb77792e2008-07-26 22:17:49 +00003693 lhptee = Context.getCanonicalType(lhptee);
3694 rhptee = Context.getCanonicalType(rhptee);
Reid Spencer5f016e22007-07-11 17:01:13 +00003695
Chris Lattner5cf216b2008-01-04 18:04:52 +00003696 AssignConvertType ConvTy = Compatible;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003697
3698 // C99 6.5.16.1p1: This following citation is common to constraints
3699 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
3700 // qualifiers of the type *pointed to* by the right;
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00003701 // FIXME: Handle ExtQualType
Douglas Gregor98cd5992008-10-21 23:43:52 +00003702 if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
Chris Lattner5cf216b2008-01-04 18:04:52 +00003703 ConvTy = CompatiblePointerDiscardsQualifiers;
Reid Spencer5f016e22007-07-11 17:01:13 +00003704
Mike Stumpeed9cac2009-02-19 03:04:26 +00003705 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
3706 // incomplete type and the other is a pointer to a qualified or unqualified
Reid Spencer5f016e22007-07-11 17:01:13 +00003707 // version of void...
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003708 if (lhptee->isVoidType()) {
Chris Lattnerd805bec2008-04-02 06:59:01 +00003709 if (rhptee->isIncompleteOrObjectType())
Chris Lattner5cf216b2008-01-04 18:04:52 +00003710 return ConvTy;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003711
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003712 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerd805bec2008-04-02 06:59:01 +00003713 assert(rhptee->isFunctionType());
3714 return FunctionVoidPointer;
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003715 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00003716
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003717 if (rhptee->isVoidType()) {
Chris Lattnerd805bec2008-04-02 06:59:01 +00003718 if (lhptee->isIncompleteOrObjectType())
Chris Lattner5cf216b2008-01-04 18:04:52 +00003719 return ConvTy;
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003720
3721 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerd805bec2008-04-02 06:59:01 +00003722 assert(lhptee->isFunctionType());
3723 return FunctionVoidPointer;
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003724 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00003725 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
Reid Spencer5f016e22007-07-11 17:01:13 +00003726 // unqualified versions of compatible types, ...
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003727 lhptee = lhptee.getUnqualifiedType();
3728 rhptee = rhptee.getUnqualifiedType();
3729 if (!Context.typesAreCompatible(lhptee, rhptee)) {
3730 // Check if the pointee types are compatible ignoring the sign.
3731 // We explicitly check for char so that we catch "char" vs
3732 // "unsigned char" on systems where "char" is unsigned.
Chris Lattner6a2b9262009-10-17 20:33:28 +00003733 if (lhptee->isCharType())
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003734 lhptee = Context.UnsignedCharTy;
Chris Lattner6a2b9262009-10-17 20:33:28 +00003735 else if (lhptee->isSignedIntegerType())
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003736 lhptee = Context.getCorrespondingUnsignedType(lhptee);
Chris Lattner6a2b9262009-10-17 20:33:28 +00003737
3738 if (rhptee->isCharType())
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003739 rhptee = Context.UnsignedCharTy;
Chris Lattner6a2b9262009-10-17 20:33:28 +00003740 else if (rhptee->isSignedIntegerType())
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003741 rhptee = Context.getCorrespondingUnsignedType(rhptee);
Chris Lattner6a2b9262009-10-17 20:33:28 +00003742
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003743 if (lhptee == rhptee) {
3744 // Types are compatible ignoring the sign. Qualifier incompatibility
3745 // takes priority over sign incompatibility because the sign
3746 // warning can be disabled.
3747 if (ConvTy != Compatible)
3748 return ConvTy;
3749 return IncompatiblePointerSign;
3750 }
3751 // General pointer incompatibility takes priority over qualifiers.
Mike Stump1eb44332009-09-09 15:08:12 +00003752 return IncompatiblePointer;
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003753 }
Chris Lattner5cf216b2008-01-04 18:04:52 +00003754 return ConvTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00003755}
3756
Steve Naroff1c7d0672008-09-04 15:10:53 +00003757/// CheckBlockPointerTypesForAssignment - This routine determines whether two
3758/// block pointer types are compatible or whether a block and normal pointer
3759/// are compatible. It is more restrict than comparing two function pointer
3760// types.
Mike Stumpeed9cac2009-02-19 03:04:26 +00003761Sema::AssignConvertType
3762Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003763 QualType rhsType) {
3764 QualType lhptee, rhptee;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003765
Steve Naroff1c7d0672008-09-04 15:10:53 +00003766 // get the "pointed to" type (ignoring qualifiers at the top level)
Ted Kremenek6217b802009-07-29 21:53:49 +00003767 lhptee = lhsType->getAs<BlockPointerType>()->getPointeeType();
3768 rhptee = rhsType->getAs<BlockPointerType>()->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00003769
Steve Naroff1c7d0672008-09-04 15:10:53 +00003770 // make sure we operate on the canonical type
3771 lhptee = Context.getCanonicalType(lhptee);
3772 rhptee = Context.getCanonicalType(rhptee);
Mike Stumpeed9cac2009-02-19 03:04:26 +00003773
Steve Naroff1c7d0672008-09-04 15:10:53 +00003774 AssignConvertType ConvTy = Compatible;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003775
Steve Naroff1c7d0672008-09-04 15:10:53 +00003776 // For blocks we enforce that qualifiers are identical.
3777 if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers())
3778 ConvTy = CompatiblePointerDiscardsQualifiers;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003779
Eli Friedman26784c12009-06-08 05:08:54 +00003780 if (!Context.typesAreCompatible(lhptee, rhptee))
Mike Stumpeed9cac2009-02-19 03:04:26 +00003781 return IncompatibleBlockPointer;
Steve Naroff1c7d0672008-09-04 15:10:53 +00003782 return ConvTy;
3783}
3784
Mike Stumpeed9cac2009-02-19 03:04:26 +00003785/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
3786/// has code to accommodate several GCC extensions when type checking
Reid Spencer5f016e22007-07-11 17:01:13 +00003787/// pointers. Here are some objectionable examples that GCC considers warnings:
3788///
3789/// int a, *pint;
3790/// short *pshort;
3791/// struct foo *pfoo;
3792///
3793/// pint = pshort; // warning: assignment from incompatible pointer type
3794/// a = pint; // warning: assignment makes integer from pointer without a cast
3795/// pint = a; // warning: assignment makes pointer from integer without a cast
3796/// pint = pfoo; // warning: assignment from incompatible pointer type
3797///
3798/// As a result, the code for dealing with pointers is more complex than the
Mike Stumpeed9cac2009-02-19 03:04:26 +00003799/// C99 spec dictates.
Reid Spencer5f016e22007-07-11 17:01:13 +00003800///
Chris Lattner5cf216b2008-01-04 18:04:52 +00003801Sema::AssignConvertType
Reid Spencer5f016e22007-07-11 17:01:13 +00003802Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
Chris Lattnerfc144e22008-01-04 23:18:45 +00003803 // Get canonical types. We're not formatting these types, just comparing
3804 // them.
Chris Lattnerb77792e2008-07-26 22:17:49 +00003805 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
3806 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003807
3808 if (lhsType == rhsType)
Chris Lattnerd2656dd2008-01-07 17:51:46 +00003809 return Compatible; // Common case: fast path an exact match.
Steve Naroff700204c2007-07-24 21:46:40 +00003810
David Chisnall0f436562009-08-17 16:35:33 +00003811 if ((lhsType->isObjCClassType() &&
3812 (rhsType.getDesugaredType() == Context.ObjCClassRedefinitionType)) ||
3813 (rhsType->isObjCClassType() &&
3814 (lhsType.getDesugaredType() == Context.ObjCClassRedefinitionType))) {
3815 return Compatible;
3816 }
3817
Douglas Gregor9d293df2008-10-28 00:22:11 +00003818 // If the left-hand side is a reference type, then we are in a
3819 // (rare!) case where we've allowed the use of references in C,
3820 // e.g., as a parameter type in a built-in function. In this case,
3821 // just make sure that the type referenced is compatible with the
3822 // right-hand side type. The caller is responsible for adjusting
3823 // lhsType so that the resulting expression does not have reference
3824 // type.
Ted Kremenek6217b802009-07-29 21:53:49 +00003825 if (const ReferenceType *lhsTypeRef = lhsType->getAs<ReferenceType>()) {
Douglas Gregor9d293df2008-10-28 00:22:11 +00003826 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType))
Anders Carlsson793680e2007-10-12 23:56:29 +00003827 return Compatible;
Chris Lattnerfc144e22008-01-04 23:18:45 +00003828 return Incompatible;
Fariborz Jahanian411f3732007-12-19 17:45:58 +00003829 }
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00003830 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
3831 // to the same ExtVector type.
3832 if (lhsType->isExtVectorType()) {
3833 if (rhsType->isExtVectorType())
3834 return lhsType == rhsType ? Compatible : Incompatible;
3835 if (!rhsType->isVectorType() && rhsType->isArithmeticType())
3836 return Compatible;
3837 }
Mike Stump1eb44332009-09-09 15:08:12 +00003838
Nate Begemanbe2341d2008-07-14 18:02:46 +00003839 if (lhsType->isVectorType() || rhsType->isVectorType()) {
Nate Begemanbe2341d2008-07-14 18:02:46 +00003840 // If we are allowing lax vector conversions, and LHS and RHS are both
Mike Stumpeed9cac2009-02-19 03:04:26 +00003841 // vectors, the total size only needs to be the same. This is a bitcast;
Nate Begemanbe2341d2008-07-14 18:02:46 +00003842 // no bits are changed but the result type is different.
Chris Lattnere8b3e962008-01-04 23:32:24 +00003843 if (getLangOptions().LaxVectorConversions &&
3844 lhsType->isVectorType() && rhsType->isVectorType()) {
Nate Begemanbe2341d2008-07-14 18:02:46 +00003845 if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00003846 return IncompatibleVectors;
Chris Lattnere8b3e962008-01-04 23:32:24 +00003847 }
3848 return Incompatible;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003849 }
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003850
Chris Lattnere8b3e962008-01-04 23:32:24 +00003851 if (lhsType->isArithmeticType() && rhsType->isArithmeticType())
Reid Spencer5f016e22007-07-11 17:01:13 +00003852 return Compatible;
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003853
Chris Lattner78eca282008-04-07 06:49:41 +00003854 if (isa<PointerType>(lhsType)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003855 if (rhsType->isIntegerType())
Chris Lattnerb7b61152008-01-04 18:22:42 +00003856 return IntToPointer;
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003857
Chris Lattner78eca282008-04-07 06:49:41 +00003858 if (isa<PointerType>(rhsType))
Reid Spencer5f016e22007-07-11 17:01:13 +00003859 return CheckPointerTypesForAssignment(lhsType, rhsType);
Mike Stumpeed9cac2009-02-19 03:04:26 +00003860
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003861 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff14108da2009-07-10 23:34:53 +00003862 if (isa<ObjCObjectPointerType>(rhsType)) {
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003863 if (lhsType->isVoidPointerType()) // an exception to the rule.
3864 return Compatible;
3865 return IncompatiblePointer;
Steve Naroff14108da2009-07-10 23:34:53 +00003866 }
Ted Kremenek6217b802009-07-29 21:53:49 +00003867 if (rhsType->getAs<BlockPointerType>()) {
3868 if (lhsType->getAs<PointerType>()->getPointeeType()->isVoidType())
Douglas Gregor63a94902008-11-27 00:44:28 +00003869 return Compatible;
Steve Naroffb4406862008-09-29 18:10:17 +00003870
3871 // Treat block pointers as objects.
Steve Naroff14108da2009-07-10 23:34:53 +00003872 if (getLangOptions().ObjC1 && lhsType->isObjCIdType())
Steve Naroffb4406862008-09-29 18:10:17 +00003873 return Compatible;
3874 }
Steve Naroff1c7d0672008-09-04 15:10:53 +00003875 return Incompatible;
3876 }
3877
3878 if (isa<BlockPointerType>(lhsType)) {
3879 if (rhsType->isIntegerType())
Eli Friedmand8f4f432009-02-25 04:20:42 +00003880 return IntToBlockPointer;
Mike Stumpeed9cac2009-02-19 03:04:26 +00003881
Steve Naroffb4406862008-09-29 18:10:17 +00003882 // Treat block pointers as objects.
Steve Naroff14108da2009-07-10 23:34:53 +00003883 if (getLangOptions().ObjC1 && rhsType->isObjCIdType())
Steve Naroffb4406862008-09-29 18:10:17 +00003884 return Compatible;
3885
Steve Naroff1c7d0672008-09-04 15:10:53 +00003886 if (rhsType->isBlockPointerType())
3887 return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
Mike Stumpeed9cac2009-02-19 03:04:26 +00003888
Ted Kremenek6217b802009-07-29 21:53:49 +00003889 if (const PointerType *RHSPT = rhsType->getAs<PointerType>()) {
Steve Naroff1c7d0672008-09-04 15:10:53 +00003890 if (RHSPT->getPointeeType()->isVoidType())
Douglas Gregor63a94902008-11-27 00:44:28 +00003891 return Compatible;
Steve Naroff1c7d0672008-09-04 15:10:53 +00003892 }
Chris Lattnerfc144e22008-01-04 23:18:45 +00003893 return Incompatible;
3894 }
3895
Steve Naroff14108da2009-07-10 23:34:53 +00003896 if (isa<ObjCObjectPointerType>(lhsType)) {
3897 if (rhsType->isIntegerType())
3898 return IntToPointer;
Mike Stump1eb44332009-09-09 15:08:12 +00003899
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003900 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff14108da2009-07-10 23:34:53 +00003901 if (isa<PointerType>(rhsType)) {
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003902 if (rhsType->isVoidPointerType()) // an exception to the rule.
3903 return Compatible;
3904 return IncompatiblePointer;
Steve Naroff14108da2009-07-10 23:34:53 +00003905 }
3906 if (rhsType->isObjCObjectPointerType()) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003907 if (lhsType->isObjCBuiltinType() || rhsType->isObjCBuiltinType())
3908 return Compatible;
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003909 if (Context.typesAreCompatible(lhsType, rhsType))
3910 return Compatible;
Steve Naroff4084c302009-07-23 01:01:38 +00003911 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType())
3912 return IncompatibleObjCQualifiedId;
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003913 return IncompatiblePointer;
Steve Naroff14108da2009-07-10 23:34:53 +00003914 }
Ted Kremenek6217b802009-07-29 21:53:49 +00003915 if (const PointerType *RHSPT = rhsType->getAs<PointerType>()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003916 if (RHSPT->getPointeeType()->isVoidType())
3917 return Compatible;
3918 }
3919 // Treat block pointers as objects.
3920 if (rhsType->isBlockPointerType())
3921 return Compatible;
3922 return Incompatible;
3923 }
Chris Lattner78eca282008-04-07 06:49:41 +00003924 if (isa<PointerType>(rhsType)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003925 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003926 if (lhsType == Context.BoolTy)
3927 return Compatible;
3928
3929 if (lhsType->isIntegerType())
Chris Lattnerb7b61152008-01-04 18:22:42 +00003930 return PointerToInt;
Reid Spencer5f016e22007-07-11 17:01:13 +00003931
Mike Stumpeed9cac2009-02-19 03:04:26 +00003932 if (isa<PointerType>(lhsType))
Reid Spencer5f016e22007-07-11 17:01:13 +00003933 return CheckPointerTypesForAssignment(lhsType, rhsType);
Mike Stumpeed9cac2009-02-19 03:04:26 +00003934
3935 if (isa<BlockPointerType>(lhsType) &&
Ted Kremenek6217b802009-07-29 21:53:49 +00003936 rhsType->getAs<PointerType>()->getPointeeType()->isVoidType())
Douglas Gregor63a94902008-11-27 00:44:28 +00003937 return Compatible;
Chris Lattnerfc144e22008-01-04 23:18:45 +00003938 return Incompatible;
Chris Lattnerfc144e22008-01-04 23:18:45 +00003939 }
Steve Naroff14108da2009-07-10 23:34:53 +00003940 if (isa<ObjCObjectPointerType>(rhsType)) {
3941 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
3942 if (lhsType == Context.BoolTy)
3943 return Compatible;
3944
3945 if (lhsType->isIntegerType())
3946 return PointerToInt;
3947
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003948 // In general, C pointers are not compatible with ObjC object pointers.
Steve Naroff14108da2009-07-10 23:34:53 +00003949 if (isa<PointerType>(lhsType)) {
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003950 if (lhsType->isVoidPointerType()) // an exception to the rule.
3951 return Compatible;
3952 return IncompatiblePointer;
Steve Naroff14108da2009-07-10 23:34:53 +00003953 }
3954 if (isa<BlockPointerType>(lhsType) &&
Ted Kremenek6217b802009-07-29 21:53:49 +00003955 rhsType->getAs<PointerType>()->getPointeeType()->isVoidType())
Steve Naroff14108da2009-07-10 23:34:53 +00003956 return Compatible;
3957 return Incompatible;
3958 }
Eli Friedmanf8f873d2008-05-30 18:07:22 +00003959
Chris Lattnerfc144e22008-01-04 23:18:45 +00003960 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
Chris Lattner78eca282008-04-07 06:49:41 +00003961 if (Context.typesAreCompatible(lhsType, rhsType))
Reid Spencer5f016e22007-07-11 17:01:13 +00003962 return Compatible;
Reid Spencer5f016e22007-07-11 17:01:13 +00003963 }
3964 return Incompatible;
3965}
3966
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003967/// \brief Constructs a transparent union from an expression that is
3968/// used to initialize the transparent union.
Mike Stump1eb44332009-09-09 15:08:12 +00003969static void ConstructTransparentUnion(ASTContext &C, Expr *&E,
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003970 QualType UnionType, FieldDecl *Field) {
3971 // Build an initializer list that designates the appropriate member
3972 // of the transparent union.
3973 InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(),
3974 &E, 1,
3975 SourceLocation());
3976 Initializer->setType(UnionType);
3977 Initializer->setInitializedFieldInUnion(Field);
3978
3979 // Build a compound literal constructing a value of the transparent
3980 // union type from this initializer list.
3981 E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer,
3982 false);
3983}
3984
3985Sema::AssignConvertType
3986Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
3987 QualType FromType = rExpr->getType();
3988
Mike Stump1eb44332009-09-09 15:08:12 +00003989 // If the ArgType is a Union type, we want to handle a potential
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003990 // transparent_union GCC extension.
3991 const RecordType *UT = ArgType->getAsUnionType();
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003992 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003993 return Incompatible;
3994
3995 // The field to initialize within the transparent union.
3996 RecordDecl *UD = UT->getDecl();
3997 FieldDecl *InitField = 0;
3998 // It's compatible if the expression matches any of the fields.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003999 for (RecordDecl::field_iterator it = UD->field_begin(),
4000 itend = UD->field_end();
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00004001 it != itend; ++it) {
4002 if (it->getType()->isPointerType()) {
4003 // If the transparent union contains a pointer type, we allow:
4004 // 1) void pointer
4005 // 2) null pointer constant
4006 if (FromType->isPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +00004007 if (FromType->getAs<PointerType>()->getPointeeType()->isVoidType()) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004008 ImpCastExprToType(rExpr, it->getType(), CastExpr::CK_BitCast);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00004009 InitField = *it;
4010 break;
4011 }
Mike Stump1eb44332009-09-09 15:08:12 +00004012
Douglas Gregorce940492009-09-25 04:25:58 +00004013 if (rExpr->isNullPointerConstant(Context,
4014 Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004015 ImpCastExprToType(rExpr, it->getType(), CastExpr::CK_IntegralToPointer);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00004016 InitField = *it;
4017 break;
4018 }
4019 }
4020
4021 if (CheckAssignmentConstraints(it->getType(), rExpr->getType())
4022 == Compatible) {
4023 InitField = *it;
4024 break;
4025 }
4026 }
4027
4028 if (!InitField)
4029 return Incompatible;
4030
4031 ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
4032 return Compatible;
4033}
4034
Chris Lattner5cf216b2008-01-04 18:04:52 +00004035Sema::AssignConvertType
Steve Naroff90045e82007-07-13 23:32:42 +00004036Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
Douglas Gregor98cd5992008-10-21 23:43:52 +00004037 if (getLangOptions().CPlusPlus) {
4038 if (!lhsType->isRecordType()) {
4039 // C++ 5.17p3: If the left operand is not of class type, the
4040 // expression is implicitly converted (C++ 4) to the
4041 // cv-unqualified type of the left operand.
Douglas Gregor45920e82008-12-19 17:40:08 +00004042 if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(),
4043 "assigning"))
Douglas Gregor98cd5992008-10-21 23:43:52 +00004044 return Incompatible;
Chris Lattner2c4463f2009-04-12 09:02:39 +00004045 return Compatible;
Douglas Gregor98cd5992008-10-21 23:43:52 +00004046 }
4047
4048 // FIXME: Currently, we fall through and treat C++ classes like C
4049 // structures.
4050 }
4051
Steve Naroff529a4ad2007-11-27 17:58:44 +00004052 // C99 6.5.16.1p1: the left operand is a pointer and the right is
4053 // a null pointer constant.
Mike Stump1eb44332009-09-09 15:08:12 +00004054 if ((lhsType->isPointerType() ||
4055 lhsType->isObjCObjectPointerType() ||
Mike Stumpeed9cac2009-02-19 03:04:26 +00004056 lhsType->isBlockPointerType())
Douglas Gregorce940492009-09-25 04:25:58 +00004057 && rExpr->isNullPointerConstant(Context,
4058 Expr::NPC_ValueDependentIsNull)) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004059 ImpCastExprToType(rExpr, lhsType, CastExpr::CK_Unknown);
Steve Naroff529a4ad2007-11-27 17:58:44 +00004060 return Compatible;
4061 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004062
Chris Lattner943140e2007-10-16 02:55:40 +00004063 // This check seems unnatural, however it is necessary to ensure the proper
Steve Naroff90045e82007-07-13 23:32:42 +00004064 // conversion of functions/arrays. If the conversion were done for all
Steve Naroff08d92e42007-09-15 18:49:24 +00004065 // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary
Steve Naroff90045e82007-07-13 23:32:42 +00004066 // expressions that surpress this implicit conversion (&, sizeof).
Chris Lattner943140e2007-10-16 02:55:40 +00004067 //
Mike Stumpeed9cac2009-02-19 03:04:26 +00004068 // Suppress this for references: C++ 8.5.3p5.
Chris Lattner943140e2007-10-16 02:55:40 +00004069 if (!lhsType->isReferenceType())
4070 DefaultFunctionArrayConversion(rExpr);
Steve Narofff1120de2007-08-24 22:33:52 +00004071
Chris Lattner5cf216b2008-01-04 18:04:52 +00004072 Sema::AssignConvertType result =
4073 CheckAssignmentConstraints(lhsType, rExpr->getType());
Mike Stumpeed9cac2009-02-19 03:04:26 +00004074
Steve Narofff1120de2007-08-24 22:33:52 +00004075 // C99 6.5.16.1p2: The value of the right operand is converted to the
4076 // type of the assignment expression.
Douglas Gregor9d293df2008-10-28 00:22:11 +00004077 // CheckAssignmentConstraints allows the left-hand side to be a reference,
4078 // so that we can use references in built-in functions even in C.
4079 // The getNonReferenceType() call makes sure that the resulting expression
4080 // does not have reference type.
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00004081 if (result != Incompatible && rExpr->getType() != lhsType)
Eli Friedman73c39ab2009-10-20 08:27:19 +00004082 ImpCastExprToType(rExpr, lhsType.getNonReferenceType(),
4083 CastExpr::CK_Unknown);
Steve Narofff1120de2007-08-24 22:33:52 +00004084 return result;
Steve Naroff90045e82007-07-13 23:32:42 +00004085}
4086
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004087QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004088 Diag(Loc, diag::err_typecheck_invalid_operands)
Chris Lattner22caddc2008-11-23 09:13:29 +00004089 << lex->getType() << rex->getType()
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004090 << lex->getSourceRange() << rex->getSourceRange();
Chris Lattnerca5eede2007-12-12 05:47:28 +00004091 return QualType();
Reid Spencer5f016e22007-07-11 17:01:13 +00004092}
4093
Mike Stumpeed9cac2009-02-19 03:04:26 +00004094inline QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex,
Steve Naroff49b45262007-07-13 16:58:59 +00004095 Expr *&rex) {
Mike Stumpeed9cac2009-02-19 03:04:26 +00004096 // For conversion purposes, we ignore any qualifiers.
Nate Begeman1330b0e2008-04-04 01:30:25 +00004097 // For example, "const float" and "float" are equivalent.
Chris Lattnerb77792e2008-07-26 22:17:49 +00004098 QualType lhsType =
4099 Context.getCanonicalType(lex->getType()).getUnqualifiedType();
4100 QualType rhsType =
4101 Context.getCanonicalType(rex->getType()).getUnqualifiedType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004102
Nate Begemanbe2341d2008-07-14 18:02:46 +00004103 // If the vector types are identical, return.
Nate Begeman1330b0e2008-04-04 01:30:25 +00004104 if (lhsType == rhsType)
Reid Spencer5f016e22007-07-11 17:01:13 +00004105 return lhsType;
Nate Begeman4119d1a2007-12-30 02:59:45 +00004106
Nate Begemanbe2341d2008-07-14 18:02:46 +00004107 // Handle the case of a vector & extvector type of the same size and element
4108 // type. It would be nice if we only had one vector type someday.
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00004109 if (getLangOptions().LaxVectorConversions) {
4110 // FIXME: Should we warn here?
John McCall183700f2009-09-21 23:43:11 +00004111 if (const VectorType *LV = lhsType->getAs<VectorType>()) {
4112 if (const VectorType *RV = rhsType->getAs<VectorType>())
Nate Begemanbe2341d2008-07-14 18:02:46 +00004113 if (LV->getElementType() == RV->getElementType() &&
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00004114 LV->getNumElements() == RV->getNumElements()) {
Nate Begemanbe2341d2008-07-14 18:02:46 +00004115 return lhsType->isExtVectorType() ? lhsType : rhsType;
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00004116 }
4117 }
4118 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004119
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00004120 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can
4121 // swap back (so that we don't reverse the inputs to a subtract, for instance.
4122 bool swapped = false;
4123 if (rhsType->isExtVectorType()) {
4124 swapped = true;
4125 std::swap(rex, lex);
4126 std::swap(rhsType, lhsType);
4127 }
Mike Stump1eb44332009-09-09 15:08:12 +00004128
Nate Begemandde25982009-06-28 19:12:57 +00004129 // Handle the case of an ext vector and scalar.
John McCall183700f2009-09-21 23:43:11 +00004130 if (const ExtVectorType *LV = lhsType->getAs<ExtVectorType>()) {
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00004131 QualType EltTy = LV->getElementType();
4132 if (EltTy->isIntegralType() && rhsType->isIntegralType()) {
4133 if (Context.getIntegerTypeOrder(EltTy, rhsType) >= 0) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004134 ImpCastExprToType(rex, lhsType, CastExpr::CK_IntegralCast);
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00004135 if (swapped) std::swap(rex, lex);
4136 return lhsType;
4137 }
4138 }
4139 if (EltTy->isRealFloatingType() && rhsType->isScalarType() &&
4140 rhsType->isRealFloatingType()) {
4141 if (Context.getFloatingTypeOrder(EltTy, rhsType) >= 0) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004142 ImpCastExprToType(rex, lhsType, CastExpr::CK_FloatingCast);
Nate Begeman1bd1f6e2009-06-28 02:36:38 +00004143 if (swapped) std::swap(rex, lex);
4144 return lhsType;
4145 }
Nate Begeman4119d1a2007-12-30 02:59:45 +00004146 }
4147 }
Mike Stump1eb44332009-09-09 15:08:12 +00004148
Nate Begemandde25982009-06-28 19:12:57 +00004149 // Vectors of different size or scalar and non-ext-vector are errors.
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004150 Diag(Loc, diag::err_typecheck_vector_not_convertable)
Chris Lattnerd1625842008-11-24 06:25:27 +00004151 << lex->getType() << rex->getType()
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004152 << lex->getSourceRange() << rex->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00004153 return QualType();
Sebastian Redl22460502009-02-07 00:15:38 +00004154}
4155
Reid Spencer5f016e22007-07-11 17:01:13 +00004156inline QualType Sema::CheckMultiplyDivideOperands(
Mike Stump1eb44332009-09-09 15:08:12 +00004157 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) {
Daniel Dunbar69d1d002009-01-05 22:42:10 +00004158 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004159 return CheckVectorOperands(Loc, lex, rex);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004160
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004161 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004162
Steve Naroffa4332e22007-07-17 00:58:39 +00004163 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004164 return compType;
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004165 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004166}
4167
4168inline QualType Sema::CheckRemainderOperands(
Mike Stump1eb44332009-09-09 15:08:12 +00004169 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) {
Daniel Dunbar523aa602009-01-05 22:55:36 +00004170 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
4171 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
4172 return CheckVectorOperands(Loc, lex, rex);
4173 return InvalidOperands(Loc, lex, rex);
4174 }
Steve Naroff90045e82007-07-13 23:32:42 +00004175
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004176 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004177
Steve Naroffa4332e22007-07-17 00:58:39 +00004178 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004179 return compType;
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004180 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004181}
4182
4183inline QualType Sema::CheckAdditionOperands( // C99 6.5.6
Mike Stump1eb44332009-09-09 15:08:12 +00004184 Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy) {
Eli Friedmanab3a8522009-03-28 01:22:36 +00004185 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
4186 QualType compType = CheckVectorOperands(Loc, lex, rex);
4187 if (CompLHSTy) *CompLHSTy = compType;
4188 return compType;
4189 }
Steve Naroff49b45262007-07-13 16:58:59 +00004190
Eli Friedmanab3a8522009-03-28 01:22:36 +00004191 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
Eli Friedmand72d16e2008-05-18 18:08:51 +00004192
Reid Spencer5f016e22007-07-11 17:01:13 +00004193 // handle the common case first (both operands are arithmetic).
Eli Friedmanab3a8522009-03-28 01:22:36 +00004194 if (lex->getType()->isArithmeticType() &&
4195 rex->getType()->isArithmeticType()) {
4196 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004197 return compType;
Eli Friedmanab3a8522009-03-28 01:22:36 +00004198 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004199
Eli Friedmand72d16e2008-05-18 18:08:51 +00004200 // Put any potential pointer into PExp
4201 Expr* PExp = lex, *IExp = rex;
Steve Naroff58f9f2c2009-07-14 18:25:06 +00004202 if (IExp->getType()->isAnyPointerType())
Eli Friedmand72d16e2008-05-18 18:08:51 +00004203 std::swap(PExp, IExp);
4204
Steve Naroff58f9f2c2009-07-14 18:25:06 +00004205 if (PExp->getType()->isAnyPointerType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00004206
Eli Friedmand72d16e2008-05-18 18:08:51 +00004207 if (IExp->getType()->isIntegerType()) {
Steve Naroff760e3c42009-07-13 21:20:41 +00004208 QualType PointeeTy = PExp->getType()->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +00004209
Chris Lattnerb5f15622009-04-24 23:50:08 +00004210 // Check for arithmetic on pointers to incomplete types.
4211 if (PointeeTy->isVoidType()) {
Douglas Gregore7450f52009-03-24 19:52:54 +00004212 if (getLangOptions().CPlusPlus) {
4213 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00004214 << lex->getSourceRange() << rex->getSourceRange();
Douglas Gregor4ec339f2009-01-19 19:26:10 +00004215 return QualType();
Eli Friedmand72d16e2008-05-18 18:08:51 +00004216 }
Douglas Gregore7450f52009-03-24 19:52:54 +00004217
4218 // GNU extension: arithmetic on pointer to void
4219 Diag(Loc, diag::ext_gnu_void_ptr)
4220 << lex->getSourceRange() << rex->getSourceRange();
Chris Lattnerb5f15622009-04-24 23:50:08 +00004221 } else if (PointeeTy->isFunctionType()) {
Douglas Gregore7450f52009-03-24 19:52:54 +00004222 if (getLangOptions().CPlusPlus) {
4223 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
4224 << lex->getType() << lex->getSourceRange();
4225 return QualType();
4226 }
4227
4228 // GNU extension: arithmetic on pointer to function
4229 Diag(Loc, diag::ext_gnu_ptr_func_arith)
4230 << lex->getType() << lex->getSourceRange();
Steve Naroff9deaeca2009-07-13 21:32:29 +00004231 } else {
Steve Naroff760e3c42009-07-13 21:20:41 +00004232 // Check if we require a complete type.
Mike Stump1eb44332009-09-09 15:08:12 +00004233 if (((PExp->getType()->isPointerType() &&
Steve Naroff9deaeca2009-07-13 21:32:29 +00004234 !PExp->getType()->isDependentType()) ||
Steve Naroff760e3c42009-07-13 21:20:41 +00004235 PExp->getType()->isObjCObjectPointerType()) &&
4236 RequireCompleteType(Loc, PointeeTy,
Mike Stump1eb44332009-09-09 15:08:12 +00004237 PDiag(diag::err_typecheck_arithmetic_incomplete_type)
4238 << PExp->getSourceRange()
Anders Carlssond497ba72009-08-26 22:59:12 +00004239 << PExp->getType()))
Steve Naroff760e3c42009-07-13 21:20:41 +00004240 return QualType();
4241 }
Chris Lattnerb5f15622009-04-24 23:50:08 +00004242 // Diagnose bad cases where we step over interface counts.
4243 if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
4244 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
4245 << PointeeTy << PExp->getSourceRange();
4246 return QualType();
4247 }
Mike Stump1eb44332009-09-09 15:08:12 +00004248
Eli Friedmanab3a8522009-03-28 01:22:36 +00004249 if (CompLHSTy) {
Eli Friedman04e83572009-08-20 04:21:42 +00004250 QualType LHSTy = Context.isPromotableBitField(lex);
4251 if (LHSTy.isNull()) {
4252 LHSTy = lex->getType();
4253 if (LHSTy->isPromotableIntegerType())
4254 LHSTy = Context.getPromotedIntegerType(LHSTy);
Douglas Gregor2d833e32009-05-02 00:36:19 +00004255 }
Eli Friedmanab3a8522009-03-28 01:22:36 +00004256 *CompLHSTy = LHSTy;
4257 }
Eli Friedmand72d16e2008-05-18 18:08:51 +00004258 return PExp->getType();
4259 }
4260 }
4261
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004262 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004263}
4264
Chris Lattnereca7be62008-04-07 05:30:13 +00004265// C99 6.5.6
4266QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
Eli Friedmanab3a8522009-03-28 01:22:36 +00004267 SourceLocation Loc, QualType* CompLHSTy) {
4268 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
4269 QualType compType = CheckVectorOperands(Loc, lex, rex);
4270 if (CompLHSTy) *CompLHSTy = compType;
4271 return compType;
4272 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004273
Eli Friedmanab3a8522009-03-28 01:22:36 +00004274 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004275
Chris Lattner6e4ab612007-12-09 21:53:25 +00004276 // Enforce type constraints: C99 6.5.6p3.
Mike Stumpeed9cac2009-02-19 03:04:26 +00004277
Chris Lattner6e4ab612007-12-09 21:53:25 +00004278 // Handle the common case first (both operands are arithmetic).
Mike Stumpaf199f32009-05-07 18:43:07 +00004279 if (lex->getType()->isArithmeticType()
4280 && rex->getType()->isArithmeticType()) {
Eli Friedmanab3a8522009-03-28 01:22:36 +00004281 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004282 return compType;
Eli Friedmanab3a8522009-03-28 01:22:36 +00004283 }
Mike Stump1eb44332009-09-09 15:08:12 +00004284
Chris Lattner6e4ab612007-12-09 21:53:25 +00004285 // Either ptr - int or ptr - ptr.
Steve Naroff58f9f2c2009-07-14 18:25:06 +00004286 if (lex->getType()->isAnyPointerType()) {
Steve Naroff430ee5a2009-07-13 17:19:15 +00004287 QualType lpointee = lex->getType()->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004288
Douglas Gregore7450f52009-03-24 19:52:54 +00004289 // The LHS must be an completely-defined object type.
Douglas Gregorc983b862009-01-23 00:36:41 +00004290
Douglas Gregore7450f52009-03-24 19:52:54 +00004291 bool ComplainAboutVoid = false;
4292 Expr *ComplainAboutFunc = 0;
4293 if (lpointee->isVoidType()) {
4294 if (getLangOptions().CPlusPlus) {
4295 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
4296 << lex->getSourceRange() << rex->getSourceRange();
4297 return QualType();
4298 }
4299
4300 // GNU C extension: arithmetic on pointer to void
4301 ComplainAboutVoid = true;
4302 } else if (lpointee->isFunctionType()) {
4303 if (getLangOptions().CPlusPlus) {
4304 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
Chris Lattnerd1625842008-11-24 06:25:27 +00004305 << lex->getType() << lex->getSourceRange();
Chris Lattner6e4ab612007-12-09 21:53:25 +00004306 return QualType();
4307 }
Douglas Gregore7450f52009-03-24 19:52:54 +00004308
4309 // GNU C extension: arithmetic on pointer to function
4310 ComplainAboutFunc = lex;
4311 } else if (!lpointee->isDependentType() &&
Mike Stump1eb44332009-09-09 15:08:12 +00004312 RequireCompleteType(Loc, lpointee,
Anders Carlssond497ba72009-08-26 22:59:12 +00004313 PDiag(diag::err_typecheck_sub_ptr_object)
Mike Stump1eb44332009-09-09 15:08:12 +00004314 << lex->getSourceRange()
Anders Carlssond497ba72009-08-26 22:59:12 +00004315 << lex->getType()))
Douglas Gregore7450f52009-03-24 19:52:54 +00004316 return QualType();
Chris Lattner6e4ab612007-12-09 21:53:25 +00004317
Chris Lattnerb5f15622009-04-24 23:50:08 +00004318 // Diagnose bad cases where we step over interface counts.
4319 if (lpointee->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
4320 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
4321 << lpointee << lex->getSourceRange();
4322 return QualType();
4323 }
Mike Stump1eb44332009-09-09 15:08:12 +00004324
Chris Lattner6e4ab612007-12-09 21:53:25 +00004325 // The result type of a pointer-int computation is the pointer type.
Douglas Gregore7450f52009-03-24 19:52:54 +00004326 if (rex->getType()->isIntegerType()) {
4327 if (ComplainAboutVoid)
4328 Diag(Loc, diag::ext_gnu_void_ptr)
4329 << lex->getSourceRange() << rex->getSourceRange();
4330 if (ComplainAboutFunc)
4331 Diag(Loc, diag::ext_gnu_ptr_func_arith)
Mike Stump1eb44332009-09-09 15:08:12 +00004332 << ComplainAboutFunc->getType()
Douglas Gregore7450f52009-03-24 19:52:54 +00004333 << ComplainAboutFunc->getSourceRange();
4334
Eli Friedmanab3a8522009-03-28 01:22:36 +00004335 if (CompLHSTy) *CompLHSTy = lex->getType();
Chris Lattner6e4ab612007-12-09 21:53:25 +00004336 return lex->getType();
Douglas Gregore7450f52009-03-24 19:52:54 +00004337 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004338
Chris Lattner6e4ab612007-12-09 21:53:25 +00004339 // Handle pointer-pointer subtractions.
Ted Kremenek6217b802009-07-29 21:53:49 +00004340 if (const PointerType *RHSPTy = rex->getType()->getAs<PointerType>()) {
Eli Friedman8e54ad02008-02-08 01:19:44 +00004341 QualType rpointee = RHSPTy->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004342
Douglas Gregore7450f52009-03-24 19:52:54 +00004343 // RHS must be a completely-type object type.
4344 // Handle the GNU void* extension.
4345 if (rpointee->isVoidType()) {
4346 if (getLangOptions().CPlusPlus) {
4347 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
4348 << lex->getSourceRange() << rex->getSourceRange();
4349 return QualType();
4350 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004351
Douglas Gregore7450f52009-03-24 19:52:54 +00004352 ComplainAboutVoid = true;
4353 } else if (rpointee->isFunctionType()) {
4354 if (getLangOptions().CPlusPlus) {
4355 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
Chris Lattnerd1625842008-11-24 06:25:27 +00004356 << rex->getType() << rex->getSourceRange();
Chris Lattner6e4ab612007-12-09 21:53:25 +00004357 return QualType();
4358 }
Douglas Gregore7450f52009-03-24 19:52:54 +00004359
4360 // GNU extension: arithmetic on pointer to function
4361 if (!ComplainAboutFunc)
4362 ComplainAboutFunc = rex;
4363 } else if (!rpointee->isDependentType() &&
4364 RequireCompleteType(Loc, rpointee,
Anders Carlssond497ba72009-08-26 22:59:12 +00004365 PDiag(diag::err_typecheck_sub_ptr_object)
4366 << rex->getSourceRange()
4367 << rex->getType()))
Douglas Gregore7450f52009-03-24 19:52:54 +00004368 return QualType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004369
Eli Friedman88d936b2009-05-16 13:54:38 +00004370 if (getLangOptions().CPlusPlus) {
4371 // Pointee types must be the same: C++ [expr.add]
4372 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
4373 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
4374 << lex->getType() << rex->getType()
4375 << lex->getSourceRange() << rex->getSourceRange();
4376 return QualType();
4377 }
4378 } else {
4379 // Pointee types must be compatible C99 6.5.6p3
4380 if (!Context.typesAreCompatible(
4381 Context.getCanonicalType(lpointee).getUnqualifiedType(),
4382 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
4383 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
4384 << lex->getType() << rex->getType()
4385 << lex->getSourceRange() << rex->getSourceRange();
4386 return QualType();
4387 }
Chris Lattner6e4ab612007-12-09 21:53:25 +00004388 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004389
Douglas Gregore7450f52009-03-24 19:52:54 +00004390 if (ComplainAboutVoid)
4391 Diag(Loc, diag::ext_gnu_void_ptr)
4392 << lex->getSourceRange() << rex->getSourceRange();
4393 if (ComplainAboutFunc)
4394 Diag(Loc, diag::ext_gnu_ptr_func_arith)
Mike Stump1eb44332009-09-09 15:08:12 +00004395 << ComplainAboutFunc->getType()
Douglas Gregore7450f52009-03-24 19:52:54 +00004396 << ComplainAboutFunc->getSourceRange();
Eli Friedmanab3a8522009-03-28 01:22:36 +00004397
4398 if (CompLHSTy) *CompLHSTy = lex->getType();
Chris Lattner6e4ab612007-12-09 21:53:25 +00004399 return Context.getPointerDiffType();
4400 }
4401 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004402
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004403 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004404}
4405
Chris Lattnereca7be62008-04-07 05:30:13 +00004406// C99 6.5.7
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004407QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
Chris Lattnereca7be62008-04-07 05:30:13 +00004408 bool isCompAssign) {
Chris Lattnerca5eede2007-12-12 05:47:28 +00004409 // C99 6.5.7p2: Each of the operands shall have integer type.
4410 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004411 return InvalidOperands(Loc, lex, rex);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004412
Nate Begeman2207d792009-10-25 02:26:48 +00004413 // Vector shifts promote their scalar inputs to vector type.
4414 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
4415 return CheckVectorOperands(Loc, lex, rex);
4416
Chris Lattnerca5eede2007-12-12 05:47:28 +00004417 // Shifts don't perform usual arithmetic conversions, they just do integer
4418 // promotions on each operand. C99 6.5.7p3
Eli Friedman04e83572009-08-20 04:21:42 +00004419 QualType LHSTy = Context.isPromotableBitField(lex);
4420 if (LHSTy.isNull()) {
4421 LHSTy = lex->getType();
4422 if (LHSTy->isPromotableIntegerType())
4423 LHSTy = Context.getPromotedIntegerType(LHSTy);
Douglas Gregor2d833e32009-05-02 00:36:19 +00004424 }
Chris Lattner1dcf2c82007-12-13 07:28:16 +00004425 if (!isCompAssign)
Eli Friedman73c39ab2009-10-20 08:27:19 +00004426 ImpCastExprToType(lex, LHSTy, CastExpr::CK_IntegralCast);
Eli Friedmanab3a8522009-03-28 01:22:36 +00004427
Chris Lattnerca5eede2007-12-12 05:47:28 +00004428 UsualUnaryConversions(rex);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004429
Ryan Flynnd0439682009-08-07 16:20:20 +00004430 // Sanity-check shift operands
4431 llvm::APSInt Right;
4432 // Check right/shifter operand
Daniel Dunbar3f180c62009-09-17 06:31:27 +00004433 if (!rex->isValueDependent() &&
4434 rex->isIntegerConstantExpr(Right, Context)) {
Ryan Flynn8045c732009-08-08 19:18:23 +00004435 if (Right.isNegative())
Ryan Flynnd0439682009-08-07 16:20:20 +00004436 Diag(Loc, diag::warn_shift_negative) << rex->getSourceRange();
4437 else {
4438 llvm::APInt LeftBits(Right.getBitWidth(),
4439 Context.getTypeSize(lex->getType()));
4440 if (Right.uge(LeftBits))
4441 Diag(Loc, diag::warn_shift_gt_typewidth) << rex->getSourceRange();
4442 }
4443 }
4444
Chris Lattnerca5eede2007-12-12 05:47:28 +00004445 // "The type of the result is that of the promoted left operand."
Eli Friedmanab3a8522009-03-28 01:22:36 +00004446 return LHSTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00004447}
4448
Douglas Gregor0c6db942009-05-04 06:07:12 +00004449// C99 6.5.8, C++ [expr.rel]
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004450QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
Douglas Gregora86b8322009-04-06 18:45:53 +00004451 unsigned OpaqueOpc, bool isRelational) {
4452 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)OpaqueOpc;
4453
Nate Begemanbe2341d2008-07-14 18:02:46 +00004454 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004455 return CheckVectorCompareOperands(lex, rex, Loc, isRelational);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004456
Chris Lattnera5937dd2007-08-26 01:18:55 +00004457 // C99 6.5.8p3 / C99 6.5.9p4
Steve Naroff30bf7712007-08-10 18:26:40 +00004458 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
4459 UsualArithmeticConversions(lex, rex);
4460 else {
4461 UsualUnaryConversions(lex);
4462 UsualUnaryConversions(rex);
4463 }
Steve Naroffc80b4ee2007-07-16 21:54:35 +00004464 QualType lType = lex->getType();
4465 QualType rType = rex->getType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004466
Mike Stumpaf199f32009-05-07 18:43:07 +00004467 if (!lType->isFloatingType()
4468 && !(lType->isBlockPointerType() && isRelational)) {
Chris Lattner55660a72009-03-08 19:39:53 +00004469 // For non-floating point types, check for self-comparisons of the form
4470 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
4471 // often indicate logic errors in the program.
Mike Stump1eb44332009-09-09 15:08:12 +00004472 // NOTE: Don't warn about comparisons of enum constants. These can arise
Ted Kremenek9ecede72009-03-20 19:57:37 +00004473 // from macro expansions, and are usually quite deliberate.
Chris Lattner55660a72009-03-08 19:39:53 +00004474 Expr *LHSStripped = lex->IgnoreParens();
4475 Expr *RHSStripped = rex->IgnoreParens();
4476 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped))
4477 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped))
Ted Kremenekb82dcd82009-03-20 18:35:45 +00004478 if (DRL->getDecl() == DRR->getDecl() &&
4479 !isa<EnumConstantDecl>(DRL->getDecl()))
Mike Stumpeed9cac2009-02-19 03:04:26 +00004480 Diag(Loc, diag::warn_selfcomparison);
Mike Stump1eb44332009-09-09 15:08:12 +00004481
Chris Lattner55660a72009-03-08 19:39:53 +00004482 if (isa<CastExpr>(LHSStripped))
4483 LHSStripped = LHSStripped->IgnoreParenCasts();
4484 if (isa<CastExpr>(RHSStripped))
4485 RHSStripped = RHSStripped->IgnoreParenCasts();
Mike Stump1eb44332009-09-09 15:08:12 +00004486
Chris Lattner55660a72009-03-08 19:39:53 +00004487 // Warn about comparisons against a string constant (unless the other
4488 // operand is null), the user probably wants strcmp.
Douglas Gregora86b8322009-04-06 18:45:53 +00004489 Expr *literalString = 0;
4490 Expr *literalStringStripped = 0;
Chris Lattner55660a72009-03-08 19:39:53 +00004491 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
Douglas Gregorce940492009-09-25 04:25:58 +00004492 !RHSStripped->isNullPointerConstant(Context,
4493 Expr::NPC_ValueDependentIsNull)) {
Douglas Gregora86b8322009-04-06 18:45:53 +00004494 literalString = lex;
4495 literalStringStripped = LHSStripped;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00004496 } else if ((isa<StringLiteral>(RHSStripped) ||
4497 isa<ObjCEncodeExpr>(RHSStripped)) &&
Douglas Gregorce940492009-09-25 04:25:58 +00004498 !LHSStripped->isNullPointerConstant(Context,
4499 Expr::NPC_ValueDependentIsNull)) {
Douglas Gregora86b8322009-04-06 18:45:53 +00004500 literalString = rex;
4501 literalStringStripped = RHSStripped;
4502 }
4503
4504 if (literalString) {
4505 std::string resultComparison;
4506 switch (Opc) {
4507 case BinaryOperator::LT: resultComparison = ") < 0"; break;
4508 case BinaryOperator::GT: resultComparison = ") > 0"; break;
4509 case BinaryOperator::LE: resultComparison = ") <= 0"; break;
4510 case BinaryOperator::GE: resultComparison = ") >= 0"; break;
4511 case BinaryOperator::EQ: resultComparison = ") == 0"; break;
4512 case BinaryOperator::NE: resultComparison = ") != 0"; break;
4513 default: assert(false && "Invalid comparison operator");
4514 }
4515 Diag(Loc, diag::warn_stringcompare)
4516 << isa<ObjCEncodeExpr>(literalStringStripped)
4517 << literalString->getSourceRange()
Douglas Gregora3a83512009-04-01 23:51:29 +00004518 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ", ")
4519 << CodeModificationHint::CreateInsertion(lex->getLocStart(),
4520 "strcmp(")
4521 << CodeModificationHint::CreateInsertion(
4522 PP.getLocForEndOfToken(rex->getLocEnd()),
Douglas Gregora86b8322009-04-06 18:45:53 +00004523 resultComparison);
4524 }
Ted Kremenek3ca0bf22007-10-29 16:58:49 +00004525 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004526
Douglas Gregor447b69e2008-11-19 03:25:36 +00004527 // The result of comparisons is 'bool' in C++, 'int' in C.
Chris Lattner55660a72009-03-08 19:39:53 +00004528 QualType ResultTy = getLangOptions().CPlusPlus? Context.BoolTy :Context.IntTy;
Douglas Gregor447b69e2008-11-19 03:25:36 +00004529
Chris Lattnera5937dd2007-08-26 01:18:55 +00004530 if (isRelational) {
4531 if (lType->isRealType() && rType->isRealType())
Douglas Gregor447b69e2008-11-19 03:25:36 +00004532 return ResultTy;
Chris Lattnera5937dd2007-08-26 01:18:55 +00004533 } else {
Ted Kremenek72cb1ae2007-10-29 17:13:39 +00004534 // Check for comparisons of floating point operands using != and ==.
Ted Kremenek72cb1ae2007-10-29 17:13:39 +00004535 if (lType->isFloatingType()) {
Chris Lattner55660a72009-03-08 19:39:53 +00004536 assert(rType->isFloatingType());
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004537 CheckFloatComparison(Loc,lex,rex);
Ted Kremenek6a261552007-10-29 16:40:01 +00004538 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004539
Chris Lattnera5937dd2007-08-26 01:18:55 +00004540 if (lType->isArithmeticType() && rType->isArithmeticType())
Douglas Gregor447b69e2008-11-19 03:25:36 +00004541 return ResultTy;
Chris Lattnera5937dd2007-08-26 01:18:55 +00004542 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004543
Douglas Gregorce940492009-09-25 04:25:58 +00004544 bool LHSIsNull = lex->isNullPointerConstant(Context,
4545 Expr::NPC_ValueDependentIsNull);
4546 bool RHSIsNull = rex->isNullPointerConstant(Context,
4547 Expr::NPC_ValueDependentIsNull);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004548
Chris Lattnera5937dd2007-08-26 01:18:55 +00004549 // All of the following pointer related warnings are GCC extensions, except
4550 // when handling null pointer constants. One day, we can consider making them
4551 // errors (when -pedantic-errors is enabled).
Steve Naroff77878cc2007-08-27 04:08:11 +00004552 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
Chris Lattnerbc896f52008-04-03 05:07:25 +00004553 QualType LCanPointeeTy =
Ted Kremenek6217b802009-07-29 21:53:49 +00004554 Context.getCanonicalType(lType->getAs<PointerType>()->getPointeeType());
Chris Lattnerbc896f52008-04-03 05:07:25 +00004555 QualType RCanPointeeTy =
Ted Kremenek6217b802009-07-29 21:53:49 +00004556 Context.getCanonicalType(rType->getAs<PointerType>()->getPointeeType());
Mike Stumpeed9cac2009-02-19 03:04:26 +00004557
Douglas Gregor0c6db942009-05-04 06:07:12 +00004558 if (getLangOptions().CPlusPlus) {
Eli Friedman3075e762009-08-23 00:27:47 +00004559 if (LCanPointeeTy == RCanPointeeTy)
4560 return ResultTy;
4561
Douglas Gregor0c6db942009-05-04 06:07:12 +00004562 // C++ [expr.rel]p2:
4563 // [...] Pointer conversions (4.10) and qualification
4564 // conversions (4.4) are performed on pointer operands (or on
4565 // a pointer operand and a null pointer constant) to bring
4566 // them to their composite pointer type. [...]
4567 //
Douglas Gregor20b3e992009-08-24 17:42:35 +00004568 // C++ [expr.eq]p1 uses the same notion for (in)equality
Douglas Gregor0c6db942009-05-04 06:07:12 +00004569 // comparisons of pointers.
Douglas Gregorde866f32009-05-05 04:50:50 +00004570 QualType T = FindCompositePointerType(lex, rex);
Douglas Gregor0c6db942009-05-04 06:07:12 +00004571 if (T.isNull()) {
4572 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
4573 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4574 return QualType();
4575 }
4576
Eli Friedman73c39ab2009-10-20 08:27:19 +00004577 ImpCastExprToType(lex, T, CastExpr::CK_BitCast);
4578 ImpCastExprToType(rex, T, CastExpr::CK_BitCast);
Douglas Gregor0c6db942009-05-04 06:07:12 +00004579 return ResultTy;
4580 }
Eli Friedman3075e762009-08-23 00:27:47 +00004581 // C99 6.5.9p2 and C99 6.5.8p2
4582 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
4583 RCanPointeeTy.getUnqualifiedType())) {
4584 // Valid unless a relational comparison of function pointers
4585 if (isRelational && LCanPointeeTy->isFunctionType()) {
4586 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
4587 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4588 }
4589 } else if (!isRelational &&
4590 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
4591 // Valid unless comparison between non-null pointer and function pointer
4592 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
4593 && !LHSIsNull && !RHSIsNull) {
4594 Diag(Loc, diag::ext_typecheck_comparison_of_fptr_to_void)
4595 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4596 }
4597 } else {
4598 // Invalid
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004599 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
Chris Lattnerd1625842008-11-24 06:25:27 +00004600 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00004601 }
Eli Friedman3075e762009-08-23 00:27:47 +00004602 if (LCanPointeeTy != RCanPointeeTy)
Eli Friedman73c39ab2009-10-20 08:27:19 +00004603 ImpCastExprToType(rex, lType, CastExpr::CK_BitCast);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004604 return ResultTy;
Steve Naroffe77fd3c2007-08-16 21:48:38 +00004605 }
Mike Stump1eb44332009-09-09 15:08:12 +00004606
Sebastian Redl6e8ed162009-05-10 18:38:11 +00004607 if (getLangOptions().CPlusPlus) {
Mike Stump1eb44332009-09-09 15:08:12 +00004608 // Comparison of pointers with null pointer constants and equality
Douglas Gregor20b3e992009-08-24 17:42:35 +00004609 // comparisons of member pointers to null pointer constants.
Mike Stump1eb44332009-09-09 15:08:12 +00004610 if (RHSIsNull &&
Douglas Gregor20b3e992009-08-24 17:42:35 +00004611 (lType->isPointerType() ||
4612 (!isRelational && lType->isMemberPointerType()))) {
Anders Carlsson26ba8502009-08-24 18:03:14 +00004613 ImpCastExprToType(rex, lType, CastExpr::CK_NullToMemberPointer);
Sebastian Redl6e8ed162009-05-10 18:38:11 +00004614 return ResultTy;
4615 }
Douglas Gregor20b3e992009-08-24 17:42:35 +00004616 if (LHSIsNull &&
4617 (rType->isPointerType() ||
4618 (!isRelational && rType->isMemberPointerType()))) {
Anders Carlsson26ba8502009-08-24 18:03:14 +00004619 ImpCastExprToType(lex, rType, CastExpr::CK_NullToMemberPointer);
Sebastian Redl6e8ed162009-05-10 18:38:11 +00004620 return ResultTy;
4621 }
Douglas Gregor20b3e992009-08-24 17:42:35 +00004622
4623 // Comparison of member pointers.
Mike Stump1eb44332009-09-09 15:08:12 +00004624 if (!isRelational &&
Douglas Gregor20b3e992009-08-24 17:42:35 +00004625 lType->isMemberPointerType() && rType->isMemberPointerType()) {
4626 // C++ [expr.eq]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00004627 // In addition, pointers to members can be compared, or a pointer to
4628 // member and a null pointer constant. Pointer to member conversions
4629 // (4.11) and qualification conversions (4.4) are performed to bring
4630 // them to a common type. If one operand is a null pointer constant,
4631 // the common type is the type of the other operand. Otherwise, the
4632 // common type is a pointer to member type similar (4.4) to the type
4633 // of one of the operands, with a cv-qualification signature (4.4)
4634 // that is the union of the cv-qualification signatures of the operand
Douglas Gregor20b3e992009-08-24 17:42:35 +00004635 // types.
4636 QualType T = FindCompositePointerType(lex, rex);
4637 if (T.isNull()) {
4638 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
4639 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4640 return QualType();
4641 }
Mike Stump1eb44332009-09-09 15:08:12 +00004642
Eli Friedman73c39ab2009-10-20 08:27:19 +00004643 ImpCastExprToType(lex, T, CastExpr::CK_BitCast);
4644 ImpCastExprToType(rex, T, CastExpr::CK_BitCast);
Douglas Gregor20b3e992009-08-24 17:42:35 +00004645 return ResultTy;
4646 }
Mike Stump1eb44332009-09-09 15:08:12 +00004647
Douglas Gregor20b3e992009-08-24 17:42:35 +00004648 // Comparison of nullptr_t with itself.
Sebastian Redl6e8ed162009-05-10 18:38:11 +00004649 if (lType->isNullPtrType() && rType->isNullPtrType())
4650 return ResultTy;
4651 }
Mike Stump1eb44332009-09-09 15:08:12 +00004652
Steve Naroff1c7d0672008-09-04 15:10:53 +00004653 // Handle block pointer types.
Mike Stumpdd3e1662009-05-07 03:14:14 +00004654 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00004655 QualType lpointee = lType->getAs<BlockPointerType>()->getPointeeType();
4656 QualType rpointee = rType->getAs<BlockPointerType>()->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004657
Steve Naroff1c7d0672008-09-04 15:10:53 +00004658 if (!LHSIsNull && !RHSIsNull &&
Eli Friedman26784c12009-06-08 05:08:54 +00004659 !Context.typesAreCompatible(lpointee, rpointee)) {
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004660 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
Chris Lattnerd1625842008-11-24 06:25:27 +00004661 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff1c7d0672008-09-04 15:10:53 +00004662 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00004663 ImpCastExprToType(rex, lType, CastExpr::CK_BitCast);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004664 return ResultTy;
Steve Naroff1c7d0672008-09-04 15:10:53 +00004665 }
Steve Naroff59f53942008-09-28 01:11:11 +00004666 // Allow block pointers to be compared with null pointer constants.
Mike Stumpdd3e1662009-05-07 03:14:14 +00004667 if (!isRelational
4668 && ((lType->isBlockPointerType() && rType->isPointerType())
4669 || (lType->isPointerType() && rType->isBlockPointerType()))) {
Steve Naroff59f53942008-09-28 01:11:11 +00004670 if (!LHSIsNull && !RHSIsNull) {
Ted Kremenek6217b802009-07-29 21:53:49 +00004671 if (!((rType->isPointerType() && rType->getAs<PointerType>()
Mike Stumpdd3e1662009-05-07 03:14:14 +00004672 ->getPointeeType()->isVoidType())
Ted Kremenek6217b802009-07-29 21:53:49 +00004673 || (lType->isPointerType() && lType->getAs<PointerType>()
Mike Stumpdd3e1662009-05-07 03:14:14 +00004674 ->getPointeeType()->isVoidType())))
4675 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4676 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroff59f53942008-09-28 01:11:11 +00004677 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00004678 ImpCastExprToType(rex, lType, CastExpr::CK_BitCast);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004679 return ResultTy;
Steve Naroff59f53942008-09-28 01:11:11 +00004680 }
Steve Naroff1c7d0672008-09-04 15:10:53 +00004681
Steve Naroff14108da2009-07-10 23:34:53 +00004682 if ((lType->isObjCObjectPointerType() || rType->isObjCObjectPointerType())) {
Steve Naroffa5ad8632008-10-27 10:33:19 +00004683 if (lType->isPointerType() || rType->isPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00004684 const PointerType *LPT = lType->getAs<PointerType>();
4685 const PointerType *RPT = rType->getAs<PointerType>();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004686 bool LPtrToVoid = LPT ?
Steve Naroffa8069f12008-11-17 19:49:16 +00004687 Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004688 bool RPtrToVoid = RPT ?
Steve Naroffa8069f12008-11-17 19:49:16 +00004689 Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004690
Steve Naroffa8069f12008-11-17 19:49:16 +00004691 if (!LPtrToVoid && !RPtrToVoid &&
4692 !Context.typesAreCompatible(lType, rType)) {
Chris Lattnerc9c7c4e2008-11-18 22:52:51 +00004693 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
Chris Lattnerd1625842008-11-24 06:25:27 +00004694 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Steve Naroffa5ad8632008-10-27 10:33:19 +00004695 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00004696 ImpCastExprToType(rex, lType, CastExpr::CK_BitCast);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004697 return ResultTy;
Steve Naroff87f3b932008-10-20 18:19:10 +00004698 }
Steve Naroff14108da2009-07-10 23:34:53 +00004699 if (lType->isObjCObjectPointerType() && rType->isObjCObjectPointerType()) {
Chris Lattner6365e3e2009-08-22 18:58:31 +00004700 if (!Context.areComparableObjCPointerTypes(lType, rType))
Steve Naroff14108da2009-07-10 23:34:53 +00004701 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4702 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Eli Friedman73c39ab2009-10-20 08:27:19 +00004703 ImpCastExprToType(rex, lType, CastExpr::CK_BitCast);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004704 return ResultTy;
Steve Naroff20373222008-06-03 14:04:54 +00004705 }
Fariborz Jahanian7359f042007-12-20 01:06:58 +00004706 }
Steve Naroff58f9f2c2009-07-14 18:25:06 +00004707 if (lType->isAnyPointerType() && rType->isIntegerType()) {
Chris Lattner06c0f5b2009-08-23 00:03:44 +00004708 unsigned DiagID = 0;
4709 if (RHSIsNull) {
4710 if (isRelational)
4711 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
4712 } else if (isRelational)
4713 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
4714 else
4715 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
Mike Stump1eb44332009-09-09 15:08:12 +00004716
Chris Lattner06c0f5b2009-08-23 00:03:44 +00004717 if (DiagID) {
Chris Lattner6365e3e2009-08-22 18:58:31 +00004718 Diag(Loc, DiagID)
Chris Lattner149f1382009-06-30 06:24:05 +00004719 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Chris Lattner6365e3e2009-08-22 18:58:31 +00004720 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00004721 ImpCastExprToType(rex, lType, CastExpr::CK_IntegralToPointer);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004722 return ResultTy;
Steve Naroffe77fd3c2007-08-16 21:48:38 +00004723 }
Steve Naroff58f9f2c2009-07-14 18:25:06 +00004724 if (lType->isIntegerType() && rType->isAnyPointerType()) {
Chris Lattner06c0f5b2009-08-23 00:03:44 +00004725 unsigned DiagID = 0;
4726 if (LHSIsNull) {
4727 if (isRelational)
4728 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
4729 } else if (isRelational)
4730 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
4731 else
4732 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
Mike Stump1eb44332009-09-09 15:08:12 +00004733
Chris Lattner06c0f5b2009-08-23 00:03:44 +00004734 if (DiagID) {
Chris Lattner6365e3e2009-08-22 18:58:31 +00004735 Diag(Loc, DiagID)
Chris Lattner149f1382009-06-30 06:24:05 +00004736 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
Chris Lattner6365e3e2009-08-22 18:58:31 +00004737 }
Eli Friedman73c39ab2009-10-20 08:27:19 +00004738 ImpCastExprToType(lex, rType, CastExpr::CK_IntegralToPointer);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004739 return ResultTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00004740 }
Steve Naroff39218df2008-09-04 16:56:14 +00004741 // Handle block pointers.
Mike Stumpaf199f32009-05-07 18:43:07 +00004742 if (!isRelational && RHSIsNull
4743 && lType->isBlockPointerType() && rType->isIntegerType()) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004744 ImpCastExprToType(rex, lType, CastExpr::CK_IntegralToPointer);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004745 return ResultTy;
Steve Naroff39218df2008-09-04 16:56:14 +00004746 }
Mike Stumpaf199f32009-05-07 18:43:07 +00004747 if (!isRelational && LHSIsNull
4748 && lType->isIntegerType() && rType->isBlockPointerType()) {
Eli Friedman73c39ab2009-10-20 08:27:19 +00004749 ImpCastExprToType(lex, rType, CastExpr::CK_IntegralToPointer);
Douglas Gregor447b69e2008-11-19 03:25:36 +00004750 return ResultTy;
Steve Naroff39218df2008-09-04 16:56:14 +00004751 }
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004752 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004753}
4754
Nate Begemanbe2341d2008-07-14 18:02:46 +00004755/// CheckVectorCompareOperands - vector comparisons are a clang extension that
Mike Stumpeed9cac2009-02-19 03:04:26 +00004756/// operates on extended vector types. Instead of producing an IntTy result,
Nate Begemanbe2341d2008-07-14 18:02:46 +00004757/// like a scalar comparison, a vector comparison produces a vector of integer
4758/// types.
4759QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004760 SourceLocation Loc,
Nate Begemanbe2341d2008-07-14 18:02:46 +00004761 bool isRelational) {
4762 // Check to make sure we're operating on vectors of the same type and width,
4763 // Allowing one side to be a scalar of element type.
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004764 QualType vType = CheckVectorOperands(Loc, lex, rex);
Nate Begemanbe2341d2008-07-14 18:02:46 +00004765 if (vType.isNull())
4766 return vType;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004767
Nate Begemanbe2341d2008-07-14 18:02:46 +00004768 QualType lType = lex->getType();
4769 QualType rType = rex->getType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004770
Nate Begemanbe2341d2008-07-14 18:02:46 +00004771 // For non-floating point types, check for self-comparisons of the form
4772 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
4773 // often indicate logic errors in the program.
4774 if (!lType->isFloatingType()) {
4775 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
4776 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
4777 if (DRL->getDecl() == DRR->getDecl())
Mike Stumpeed9cac2009-02-19 03:04:26 +00004778 Diag(Loc, diag::warn_selfcomparison);
Nate Begemanbe2341d2008-07-14 18:02:46 +00004779 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004780
Nate Begemanbe2341d2008-07-14 18:02:46 +00004781 // Check for comparisons of floating point operands using != and ==.
4782 if (!isRelational && lType->isFloatingType()) {
4783 assert (rType->isFloatingType());
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004784 CheckFloatComparison(Loc,lex,rex);
Nate Begemanbe2341d2008-07-14 18:02:46 +00004785 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00004786
Nate Begemanbe2341d2008-07-14 18:02:46 +00004787 // Return the type for the comparison, which is the same as vector type for
4788 // integer vectors, or an integer type of identical size and number of
4789 // elements for floating point vectors.
4790 if (lType->isIntegerType())
4791 return lType;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004792
John McCall183700f2009-09-21 23:43:11 +00004793 const VectorType *VTy = lType->getAs<VectorType>();
Nate Begemanbe2341d2008-07-14 18:02:46 +00004794 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
Nate Begeman59b5da62009-01-18 03:20:47 +00004795 if (TypeSize == Context.getTypeSize(Context.IntTy))
Nate Begemanbe2341d2008-07-14 18:02:46 +00004796 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
Chris Lattnerd013aa12009-03-31 07:46:52 +00004797 if (TypeSize == Context.getTypeSize(Context.LongTy))
Nate Begeman59b5da62009-01-18 03:20:47 +00004798 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
4799
Mike Stumpeed9cac2009-02-19 03:04:26 +00004800 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
Nate Begeman59b5da62009-01-18 03:20:47 +00004801 "Unhandled vector element size in vector compare");
Nate Begemanbe2341d2008-07-14 18:02:46 +00004802 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
4803}
4804
Reid Spencer5f016e22007-07-11 17:01:13 +00004805inline QualType Sema::CheckBitwiseOperands(
Mike Stump1eb44332009-09-09 15:08:12 +00004806 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) {
Steve Naroff3e5e5562007-07-16 22:23:01 +00004807 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004808 return CheckVectorOperands(Loc, lex, rex);
Steve Naroff90045e82007-07-13 23:32:42 +00004809
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004810 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004811
Steve Naroffa4332e22007-07-17 00:58:39 +00004812 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00004813 return compType;
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004814 return InvalidOperands(Loc, lex, rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00004815}
4816
4817inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
Mike Stump1eb44332009-09-09 15:08:12 +00004818 Expr *&lex, Expr *&rex, SourceLocation Loc) {
Steve Naroffc80b4ee2007-07-16 21:54:35 +00004819 UsualUnaryConversions(lex);
4820 UsualUnaryConversions(rex);
Mike Stumpeed9cac2009-02-19 03:04:26 +00004821
Anders Carlsson04905012009-10-16 01:44:21 +00004822 if (!lex->getType()->isScalarType() || !rex->getType()->isScalarType())
4823 return InvalidOperands(Loc, lex, rex);
4824
4825 if (Context.getLangOptions().CPlusPlus) {
4826 // C++ [expr.log.and]p2
4827 // C++ [expr.log.or]p2
4828 return Context.BoolTy;
4829 }
4830
4831 return Context.IntTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00004832}
4833
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00004834/// IsReadonlyProperty - Verify that otherwise a valid l-value expression
4835/// is a read-only property; return true if so. A readonly property expression
4836/// depends on various declarations and thus must be treated specially.
4837///
Mike Stump1eb44332009-09-09 15:08:12 +00004838static bool IsReadonlyProperty(Expr *E, Sema &S) {
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00004839 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) {
4840 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E);
4841 if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) {
4842 QualType BaseType = PropExpr->getBase()->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00004843 if (const ObjCObjectPointerType *OPT =
Steve Naroff14108da2009-07-10 23:34:53 +00004844 BaseType->getAsObjCInterfacePointerType())
4845 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl())
4846 if (S.isPropertyReadonly(PDecl, IFace))
4847 return true;
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00004848 }
4849 }
4850 return false;
4851}
4852
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004853/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
4854/// emit an error and return true. If so, return false.
4855static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
Daniel Dunbar44e35f72009-04-15 00:08:05 +00004856 SourceLocation OrigLoc = Loc;
Mike Stump1eb44332009-09-09 15:08:12 +00004857 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
Daniel Dunbar44e35f72009-04-15 00:08:05 +00004858 &Loc);
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00004859 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S))
4860 IsLV = Expr::MLV_ReadonlyProperty;
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004861 if (IsLV == Expr::MLV_Valid)
4862 return false;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004863
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004864 unsigned Diag = 0;
4865 bool NeedType = false;
4866 switch (IsLV) { // C99 6.5.16p2
4867 default: assert(0 && "Unknown result from isModifiableLvalue!");
4868 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004869 case Expr::MLV_ArrayType:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004870 Diag = diag::err_typecheck_array_not_modifiable_lvalue;
4871 NeedType = true;
4872 break;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004873 case Expr::MLV_NotObjectType:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004874 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
4875 NeedType = true;
4876 break;
Chris Lattnerca354fa2008-11-17 19:51:54 +00004877 case Expr::MLV_LValueCast:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004878 Diag = diag::err_typecheck_lvalue_casts_not_supported;
4879 break;
Chris Lattner5cf216b2008-01-04 18:04:52 +00004880 case Expr::MLV_InvalidExpression:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004881 Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
4882 break;
Chris Lattner5cf216b2008-01-04 18:04:52 +00004883 case Expr::MLV_IncompleteType:
4884 case Expr::MLV_IncompleteVoidType:
Douglas Gregor86447ec2009-03-09 16:13:40 +00004885 return S.RequireCompleteType(Loc, E->getType(),
Anders Carlssonb7906612009-08-26 23:45:07 +00004886 PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue)
4887 << E->getSourceRange());
Chris Lattner5cf216b2008-01-04 18:04:52 +00004888 case Expr::MLV_DuplicateVectorComponents:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004889 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
4890 break;
Steve Naroff4f6a7d72008-09-26 14:41:28 +00004891 case Expr::MLV_NotBlockQualified:
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004892 Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
4893 break;
Fariborz Jahanian5daf5702008-11-22 18:39:36 +00004894 case Expr::MLV_ReadonlyProperty:
4895 Diag = diag::error_readonly_property_assignment;
4896 break;
Fariborz Jahanianba8d2d62008-11-22 20:25:50 +00004897 case Expr::MLV_NoSetterProperty:
4898 Diag = diag::error_nosetter_property_assignment;
4899 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00004900 }
Steve Naroffd1861fd2007-07-31 12:34:36 +00004901
Daniel Dunbar44e35f72009-04-15 00:08:05 +00004902 SourceRange Assign;
4903 if (Loc != OrigLoc)
4904 Assign = SourceRange(OrigLoc, OrigLoc);
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004905 if (NeedType)
Daniel Dunbar44e35f72009-04-15 00:08:05 +00004906 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004907 else
Mike Stump1eb44332009-09-09 15:08:12 +00004908 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004909 return true;
4910}
4911
4912
4913
4914// C99 6.5.16.1
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004915QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS,
4916 SourceLocation Loc,
4917 QualType CompoundType) {
4918 // Verify that LHS is a modifiable lvalue, and emit error if not.
4919 if (CheckForModifiableLvalue(LHS, Loc, *this))
Chris Lattnerf67bd9f2008-11-18 01:22:49 +00004920 return QualType();
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004921
4922 QualType LHSType = LHS->getType();
4923 QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004924
Chris Lattner5cf216b2008-01-04 18:04:52 +00004925 AssignConvertType ConvTy;
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004926 if (CompoundType.isNull()) {
Chris Lattner2c156472008-08-21 18:04:13 +00004927 // Simple assignment "x = y".
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004928 ConvTy = CheckSingleAssignmentConstraints(LHSType, RHS);
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00004929 // Special case of NSObject attributes on c-style pointer types.
4930 if (ConvTy == IncompatiblePointer &&
4931 ((Context.isObjCNSObjectType(LHSType) &&
Steve Narofff4954562009-07-16 15:41:00 +00004932 RHSType->isObjCObjectPointerType()) ||
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00004933 (Context.isObjCNSObjectType(RHSType) &&
Steve Narofff4954562009-07-16 15:41:00 +00004934 LHSType->isObjCObjectPointerType())))
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00004935 ConvTy = Compatible;
Mike Stumpeed9cac2009-02-19 03:04:26 +00004936
Chris Lattner2c156472008-08-21 18:04:13 +00004937 // If the RHS is a unary plus or minus, check to see if they = and + are
4938 // right next to each other. If so, the user may have typo'd "x =+ 4"
4939 // instead of "x += 4".
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004940 Expr *RHSCheck = RHS;
Chris Lattner2c156472008-08-21 18:04:13 +00004941 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
4942 RHSCheck = ICE->getSubExpr();
4943 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
4944 if ((UO->getOpcode() == UnaryOperator::Plus ||
4945 UO->getOpcode() == UnaryOperator::Minus) &&
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004946 Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
Chris Lattner2c156472008-08-21 18:04:13 +00004947 // Only if the two operators are exactly adjacent.
Chris Lattner399bd1b2009-03-08 06:51:10 +00004948 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() &&
4949 // And there is a space or other character before the subexpr of the
4950 // unary +/-. We don't want to warn on "x=-1".
Chris Lattner3e872092009-03-09 07:11:10 +00004951 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
4952 UO->getSubExpr()->getLocStart().isFileID()) {
Chris Lattnerd3a94e22008-11-20 06:06:08 +00004953 Diag(Loc, diag::warn_not_compound_assign)
4954 << (UO->getOpcode() == UnaryOperator::Plus ? "+" : "-")
4955 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
Chris Lattner399bd1b2009-03-08 06:51:10 +00004956 }
Chris Lattner2c156472008-08-21 18:04:13 +00004957 }
4958 } else {
4959 // Compound assignment "x += y"
Eli Friedman623712b2009-05-16 05:56:02 +00004960 ConvTy = CheckAssignmentConstraints(LHSType, RHSType);
Chris Lattner2c156472008-08-21 18:04:13 +00004961 }
Chris Lattner5cf216b2008-01-04 18:04:52 +00004962
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004963 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
4964 RHS, "assigning"))
Chris Lattner5cf216b2008-01-04 18:04:52 +00004965 return QualType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00004966
Reid Spencer5f016e22007-07-11 17:01:13 +00004967 // C99 6.5.16p3: The type of an assignment expression is the type of the
4968 // left operand unless the left operand has qualified type, in which case
Mike Stumpeed9cac2009-02-19 03:04:26 +00004969 // it is the unqualified version of the type of the left operand.
Reid Spencer5f016e22007-07-11 17:01:13 +00004970 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
4971 // is converted to the type of the assignment expression (above).
Chris Lattner73d0d4f2007-08-30 17:45:32 +00004972 // C++ 5.17p1: the type of the assignment expression is that of its left
Douglas Gregor2d833e32009-05-02 00:36:19 +00004973 // operand.
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004974 return LHSType.getUnqualifiedType();
Reid Spencer5f016e22007-07-11 17:01:13 +00004975}
4976
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004977// C99 6.5.17
4978QualType Sema::CheckCommaOperands(Expr *LHS, Expr *&RHS, SourceLocation Loc) {
Chris Lattner53fcaa92008-07-25 20:54:07 +00004979 // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions.
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004980 DefaultFunctionArrayConversion(RHS);
Eli Friedmanb1d796d2009-03-23 00:24:07 +00004981
4982 // FIXME: Check that RHS type is complete in C mode (it's legal for it to be
4983 // incomplete in C++).
4984
Chris Lattner29a1cfb2008-11-18 01:30:42 +00004985 return RHS->getType();
Reid Spencer5f016e22007-07-11 17:01:13 +00004986}
4987
Steve Naroff49b45262007-07-13 16:58:59 +00004988/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
4989/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00004990QualType Sema::CheckIncrementDecrementOperand(Expr *Op, SourceLocation OpLoc,
4991 bool isInc) {
Sebastian Redl28507842009-02-26 14:39:58 +00004992 if (Op->isTypeDependent())
4993 return Context.DependentTy;
4994
Chris Lattner3528d352008-11-21 07:05:48 +00004995 QualType ResType = Op->getType();
4996 assert(!ResType.isNull() && "no type for increment/decrement expression");
Reid Spencer5f016e22007-07-11 17:01:13 +00004997
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00004998 if (getLangOptions().CPlusPlus && ResType->isBooleanType()) {
4999 // Decrement of bool is not allowed.
5000 if (!isInc) {
5001 Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
5002 return QualType();
5003 }
5004 // Increment of bool sets it to true, but is deprecated.
5005 Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
5006 } else if (ResType->isRealType()) {
Chris Lattner3528d352008-11-21 07:05:48 +00005007 // OK!
Steve Naroff58f9f2c2009-07-14 18:25:06 +00005008 } else if (ResType->isAnyPointerType()) {
5009 QualType PointeeTy = ResType->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +00005010
Chris Lattner3528d352008-11-21 07:05:48 +00005011 // C99 6.5.2.4p2, 6.5.6p2
Steve Naroff14108da2009-07-10 23:34:53 +00005012 if (PointeeTy->isVoidType()) {
Douglas Gregorc983b862009-01-23 00:36:41 +00005013 if (getLangOptions().CPlusPlus) {
5014 Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type)
5015 << Op->getSourceRange();
5016 return QualType();
5017 }
5018
5019 // Pointer to void is a GNU extension in C.
Chris Lattner3528d352008-11-21 07:05:48 +00005020 Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange();
Steve Naroff14108da2009-07-10 23:34:53 +00005021 } else if (PointeeTy->isFunctionType()) {
Douglas Gregorc983b862009-01-23 00:36:41 +00005022 if (getLangOptions().CPlusPlus) {
5023 Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type)
5024 << Op->getType() << Op->getSourceRange();
5025 return QualType();
5026 }
5027
5028 Diag(OpLoc, diag::ext_gnu_ptr_func_arith)
Chris Lattnerd1625842008-11-24 06:25:27 +00005029 << ResType << Op->getSourceRange();
Steve Naroff14108da2009-07-10 23:34:53 +00005030 } else if (RequireCompleteType(OpLoc, PointeeTy,
Anders Carlssond497ba72009-08-26 22:59:12 +00005031 PDiag(diag::err_typecheck_arithmetic_incomplete_type)
Mike Stump1eb44332009-09-09 15:08:12 +00005032 << Op->getSourceRange()
Anders Carlssond497ba72009-08-26 22:59:12 +00005033 << ResType))
Douglas Gregor4ec339f2009-01-19 19:26:10 +00005034 return QualType();
Fariborz Jahanian9f8a04f2009-07-16 17:59:14 +00005035 // Diagnose bad cases where we step over interface counts.
5036 else if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
5037 Diag(OpLoc, diag::err_arithmetic_nonfragile_interface)
5038 << PointeeTy << Op->getSourceRange();
5039 return QualType();
5040 }
Chris Lattner3528d352008-11-21 07:05:48 +00005041 } else if (ResType->isComplexType()) {
5042 // C99 does not support ++/-- on complex types, we allow as an extension.
5043 Diag(OpLoc, diag::ext_integer_increment_complex)
Chris Lattnerd1625842008-11-24 06:25:27 +00005044 << ResType << Op->getSourceRange();
Chris Lattner3528d352008-11-21 07:05:48 +00005045 } else {
5046 Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
Chris Lattnerd1625842008-11-24 06:25:27 +00005047 << ResType << Op->getSourceRange();
Chris Lattner3528d352008-11-21 07:05:48 +00005048 return QualType();
Reid Spencer5f016e22007-07-11 17:01:13 +00005049 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00005050 // At this point, we know we have a real, complex or pointer type.
Steve Naroffdd10e022007-08-23 21:37:33 +00005051 // Now make sure the operand is a modifiable lvalue.
Chris Lattner3528d352008-11-21 07:05:48 +00005052 if (CheckForModifiableLvalue(Op, OpLoc, *this))
Reid Spencer5f016e22007-07-11 17:01:13 +00005053 return QualType();
Chris Lattner3528d352008-11-21 07:05:48 +00005054 return ResType;
Reid Spencer5f016e22007-07-11 17:01:13 +00005055}
5056
Anders Carlsson369dee42008-02-01 07:15:58 +00005057/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
Reid Spencer5f016e22007-07-11 17:01:13 +00005058/// This routine allows us to typecheck complex/recursive expressions
Daniel Dunbar1e76ce62008-08-04 20:02:37 +00005059/// where the declaration is needed for type checking. We only need to
5060/// handle cases when the expression references a function designator
5061/// or is an lvalue. Here are some examples:
5062/// - &(x) => x
5063/// - &*****f => f for f a function designator.
5064/// - &s.xx => s
5065/// - &s.zz[1].yy -> s, if zz is an array
5066/// - *(x + 1) -> x, if x is an array
5067/// - &"123"[2] -> 0
5068/// - & __real__ x -> x
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00005069static NamedDecl *getPrimaryDecl(Expr *E) {
Chris Lattnerf0467b32008-04-02 04:24:33 +00005070 switch (E->getStmtClass()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005071 case Stmt::DeclRefExprClass:
Chris Lattnerf0467b32008-04-02 04:24:33 +00005072 return cast<DeclRefExpr>(E)->getDecl();
Reid Spencer5f016e22007-07-11 17:01:13 +00005073 case Stmt::MemberExprClass:
Eli Friedman23d58ce2009-04-20 08:23:18 +00005074 // If this is an arrow operator, the address is an offset from
5075 // the base's value, so the object the base refers to is
5076 // irrelevant.
Chris Lattnerf0467b32008-04-02 04:24:33 +00005077 if (cast<MemberExpr>(E)->isArrow())
Chris Lattnerf82228f2007-11-16 17:46:48 +00005078 return 0;
Eli Friedman23d58ce2009-04-20 08:23:18 +00005079 // Otherwise, the expression refers to a part of the base
Chris Lattnerf0467b32008-04-02 04:24:33 +00005080 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
Anders Carlsson369dee42008-02-01 07:15:58 +00005081 case Stmt::ArraySubscriptExprClass: {
Mike Stump390b4cc2009-05-16 07:39:55 +00005082 // FIXME: This code shouldn't be necessary! We should catch the implicit
5083 // promotion of register arrays earlier.
Eli Friedman23d58ce2009-04-20 08:23:18 +00005084 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
5085 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
5086 if (ICE->getSubExpr()->getType()->isArrayType())
5087 return getPrimaryDecl(ICE->getSubExpr());
5088 }
5089 return 0;
Anders Carlsson369dee42008-02-01 07:15:58 +00005090 }
Daniel Dunbar1e76ce62008-08-04 20:02:37 +00005091 case Stmt::UnaryOperatorClass: {
5092 UnaryOperator *UO = cast<UnaryOperator>(E);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005093
Daniel Dunbar1e76ce62008-08-04 20:02:37 +00005094 switch(UO->getOpcode()) {
Daniel Dunbar1e76ce62008-08-04 20:02:37 +00005095 case UnaryOperator::Real:
5096 case UnaryOperator::Imag:
5097 case UnaryOperator::Extension:
5098 return getPrimaryDecl(UO->getSubExpr());
5099 default:
5100 return 0;
5101 }
5102 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005103 case Stmt::ParenExprClass:
Chris Lattnerf0467b32008-04-02 04:24:33 +00005104 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
Chris Lattnerf82228f2007-11-16 17:46:48 +00005105 case Stmt::ImplicitCastExprClass:
Eli Friedman23d58ce2009-04-20 08:23:18 +00005106 // If the result of an implicit cast is an l-value, we care about
5107 // the sub-expression; otherwise, the result here doesn't matter.
Chris Lattnerf0467b32008-04-02 04:24:33 +00005108 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
Reid Spencer5f016e22007-07-11 17:01:13 +00005109 default:
5110 return 0;
5111 }
5112}
5113
5114/// CheckAddressOfOperand - The operand of & must be either a function
Mike Stumpeed9cac2009-02-19 03:04:26 +00005115/// designator or an lvalue designating an object. If it is an lvalue, the
Reid Spencer5f016e22007-07-11 17:01:13 +00005116/// object cannot be declared with storage class register or be a bit field.
Mike Stumpeed9cac2009-02-19 03:04:26 +00005117/// Note: The usual conversions are *not* applied to the operand of the &
Reid Spencer5f016e22007-07-11 17:01:13 +00005118/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
Mike Stumpeed9cac2009-02-19 03:04:26 +00005119/// In C++, the operand might be an overloaded function name, in which case
Douglas Gregor904eed32008-11-10 20:40:00 +00005120/// we allow the '&' but retain the overloaded-function type.
Reid Spencer5f016e22007-07-11 17:01:13 +00005121QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) {
Eli Friedman23d58ce2009-04-20 08:23:18 +00005122 // Make sure to ignore parentheses in subsequent checks
5123 op = op->IgnoreParens();
5124
Douglas Gregor9103bb22008-12-17 22:52:20 +00005125 if (op->isTypeDependent())
5126 return Context.DependentTy;
5127
Steve Naroff08f19672008-01-13 17:10:08 +00005128 if (getLangOptions().C99) {
5129 // Implement C99-only parts of addressof rules.
5130 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
5131 if (uOp->getOpcode() == UnaryOperator::Deref)
5132 // Per C99 6.5.3.2, the address of a deref always returns a valid result
5133 // (assuming the deref expression is valid).
5134 return uOp->getSubExpr()->getType();
5135 }
5136 // Technically, there should be a check for array subscript
5137 // expressions here, but the result of one is always an lvalue anyway.
5138 }
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00005139 NamedDecl *dcl = getPrimaryDecl(op);
Chris Lattner28be73f2008-07-26 21:30:36 +00005140 Expr::isLvalueResult lval = op->isLvalue(Context);
Nuno Lopes6b6609f2008-12-16 22:59:47 +00005141
Eli Friedman441cf102009-05-16 23:27:50 +00005142 if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
5143 // C99 6.5.3.2p1
Eli Friedman23d58ce2009-04-20 08:23:18 +00005144 // The operand must be either an l-value or a function designator
Eli Friedman441cf102009-05-16 23:27:50 +00005145 if (!op->getType()->isFunctionType()) {
Chris Lattnerf82228f2007-11-16 17:46:48 +00005146 // FIXME: emit more specific diag...
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00005147 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
5148 << op->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00005149 return QualType();
5150 }
Douglas Gregor33bbbc52009-05-02 02:18:30 +00005151 } else if (op->getBitField()) { // C99 6.5.3.2p1
Eli Friedman23d58ce2009-04-20 08:23:18 +00005152 // The operand cannot be a bit-field
5153 Diag(OpLoc, diag::err_typecheck_address_of)
5154 << "bit-field" << op->getSourceRange();
Douglas Gregor86f19402008-12-20 23:49:58 +00005155 return QualType();
Nate Begemanb104b1f2009-02-15 22:45:20 +00005156 } else if (isa<ExtVectorElementExpr>(op) || (isa<ArraySubscriptExpr>(op) &&
5157 cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType())){
Eli Friedman23d58ce2009-04-20 08:23:18 +00005158 // The operand cannot be an element of a vector
Chris Lattnerd3a94e22008-11-20 06:06:08 +00005159 Diag(OpLoc, diag::err_typecheck_address_of)
Nate Begemanb104b1f2009-02-15 22:45:20 +00005160 << "vector element" << op->getSourceRange();
Steve Naroffbcb2b612008-02-29 23:30:25 +00005161 return QualType();
Fariborz Jahanian0337f212009-07-07 18:50:52 +00005162 } else if (isa<ObjCPropertyRefExpr>(op)) {
5163 // cannot take address of a property expression.
5164 Diag(OpLoc, diag::err_typecheck_address_of)
5165 << "property expression" << op->getSourceRange();
5166 return QualType();
Anders Carlsson1d524c32009-09-14 23:15:26 +00005167 } else if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(op)) {
5168 // FIXME: Can LHS ever be null here?
Anders Carlsson474e1022009-09-15 16:03:44 +00005169 if (!CheckAddressOfOperand(CO->getTrueExpr(), OpLoc).isNull())
5170 return CheckAddressOfOperand(CO->getFalseExpr(), OpLoc);
Steve Naroffbcb2b612008-02-29 23:30:25 +00005171 } else if (dcl) { // C99 6.5.3.2p1
Mike Stumpeed9cac2009-02-19 03:04:26 +00005172 // We have an lvalue with a decl. Make sure the decl is not declared
Reid Spencer5f016e22007-07-11 17:01:13 +00005173 // with the register storage-class specifier.
5174 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
5175 if (vd->getStorageClass() == VarDecl::Register) {
Chris Lattnerd3a94e22008-11-20 06:06:08 +00005176 Diag(OpLoc, diag::err_typecheck_address_of)
5177 << "register variable" << op->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00005178 return QualType();
5179 }
Douglas Gregor83314aa2009-07-08 20:55:45 +00005180 } else if (isa<OverloadedFunctionDecl>(dcl) ||
5181 isa<FunctionTemplateDecl>(dcl)) {
Douglas Gregor904eed32008-11-10 20:40:00 +00005182 return Context.OverloadTy;
Anders Carlssonf9e48bd2009-07-08 21:45:58 +00005183 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(dcl)) {
Douglas Gregor29882052008-12-10 21:26:49 +00005184 // Okay: we can take the address of a field.
Sebastian Redlebc07d52009-02-03 20:19:35 +00005185 // Could be a pointer to member, though, if there is an explicit
5186 // scope qualifier for the class.
Douglas Gregora2813ce2009-10-23 18:54:35 +00005187 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
Sebastian Redlebc07d52009-02-03 20:19:35 +00005188 DeclContext *Ctx = dcl->getDeclContext();
Anders Carlssonf9e48bd2009-07-08 21:45:58 +00005189 if (Ctx && Ctx->isRecord()) {
5190 if (FD->getType()->isReferenceType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005191 Diag(OpLoc,
Anders Carlssonf9e48bd2009-07-08 21:45:58 +00005192 diag::err_cannot_form_pointer_to_member_of_reference_type)
5193 << FD->getDeclName() << FD->getType();
5194 return QualType();
5195 }
Mike Stump1eb44332009-09-09 15:08:12 +00005196
Sebastian Redlebc07d52009-02-03 20:19:35 +00005197 return Context.getMemberPointerType(op->getType(),
5198 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
Anders Carlssonf9e48bd2009-07-08 21:45:58 +00005199 }
Sebastian Redlebc07d52009-02-03 20:19:35 +00005200 }
Anders Carlsson196f7d02009-05-16 21:43:42 +00005201 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(dcl)) {
Nuno Lopes6fea8d22008-12-16 22:58:26 +00005202 // Okay: we can take the address of a function.
Sebastian Redl33b399a2009-02-04 21:23:32 +00005203 // As above.
Douglas Gregora2813ce2009-10-23 18:54:35 +00005204 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier() &&
5205 MD->isInstance())
Anders Carlsson196f7d02009-05-16 21:43:42 +00005206 return Context.getMemberPointerType(op->getType(),
5207 Context.getTypeDeclType(MD->getParent()).getTypePtr());
5208 } else if (!isa<FunctionDecl>(dcl))
Reid Spencer5f016e22007-07-11 17:01:13 +00005209 assert(0 && "Unknown/unexpected decl type");
Reid Spencer5f016e22007-07-11 17:01:13 +00005210 }
Sebastian Redl33b399a2009-02-04 21:23:32 +00005211
Eli Friedman441cf102009-05-16 23:27:50 +00005212 if (lval == Expr::LV_IncompleteVoidType) {
5213 // Taking the address of a void variable is technically illegal, but we
5214 // allow it in cases which are otherwise valid.
5215 // Example: "extern void x; void* y = &x;".
5216 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
5217 }
5218
Reid Spencer5f016e22007-07-11 17:01:13 +00005219 // If the operand has type "type", the result has type "pointer to type".
5220 return Context.getPointerType(op->getType());
5221}
5222
Chris Lattner22caddc2008-11-23 09:13:29 +00005223QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) {
Sebastian Redl28507842009-02-26 14:39:58 +00005224 if (Op->isTypeDependent())
5225 return Context.DependentTy;
5226
Chris Lattner22caddc2008-11-23 09:13:29 +00005227 UsualUnaryConversions(Op);
5228 QualType Ty = Op->getType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00005229
Chris Lattner22caddc2008-11-23 09:13:29 +00005230 // Note that per both C89 and C99, this is always legal, even if ptype is an
5231 // incomplete type or void. It would be possible to warn about dereferencing
5232 // a void pointer, but it's completely well-defined, and such a warning is
5233 // unlikely to catch any mistakes.
Ted Kremenek6217b802009-07-29 21:53:49 +00005234 if (const PointerType *PT = Ty->getAs<PointerType>())
Steve Naroff08f19672008-01-13 17:10:08 +00005235 return PT->getPointeeType();
Mike Stumpeed9cac2009-02-19 03:04:26 +00005236
John McCall183700f2009-09-21 23:43:11 +00005237 if (const ObjCObjectPointerType *OPT = Ty->getAs<ObjCObjectPointerType>())
Fariborz Jahanian16b10372009-09-03 00:43:07 +00005238 return OPT->getPointeeType();
Steve Naroff14108da2009-07-10 23:34:53 +00005239
Chris Lattnerd3a94e22008-11-20 06:06:08 +00005240 Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
Chris Lattner22caddc2008-11-23 09:13:29 +00005241 << Ty << Op->getSourceRange();
Reid Spencer5f016e22007-07-11 17:01:13 +00005242 return QualType();
5243}
5244
5245static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode(
5246 tok::TokenKind Kind) {
5247 BinaryOperator::Opcode Opc;
5248 switch (Kind) {
5249 default: assert(0 && "Unknown binop!");
Sebastian Redl22460502009-02-07 00:15:38 +00005250 case tok::periodstar: Opc = BinaryOperator::PtrMemD; break;
5251 case tok::arrowstar: Opc = BinaryOperator::PtrMemI; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00005252 case tok::star: Opc = BinaryOperator::Mul; break;
5253 case tok::slash: Opc = BinaryOperator::Div; break;
5254 case tok::percent: Opc = BinaryOperator::Rem; break;
5255 case tok::plus: Opc = BinaryOperator::Add; break;
5256 case tok::minus: Opc = BinaryOperator::Sub; break;
5257 case tok::lessless: Opc = BinaryOperator::Shl; break;
5258 case tok::greatergreater: Opc = BinaryOperator::Shr; break;
5259 case tok::lessequal: Opc = BinaryOperator::LE; break;
5260 case tok::less: Opc = BinaryOperator::LT; break;
5261 case tok::greaterequal: Opc = BinaryOperator::GE; break;
5262 case tok::greater: Opc = BinaryOperator::GT; break;
5263 case tok::exclaimequal: Opc = BinaryOperator::NE; break;
5264 case tok::equalequal: Opc = BinaryOperator::EQ; break;
5265 case tok::amp: Opc = BinaryOperator::And; break;
5266 case tok::caret: Opc = BinaryOperator::Xor; break;
5267 case tok::pipe: Opc = BinaryOperator::Or; break;
5268 case tok::ampamp: Opc = BinaryOperator::LAnd; break;
5269 case tok::pipepipe: Opc = BinaryOperator::LOr; break;
5270 case tok::equal: Opc = BinaryOperator::Assign; break;
5271 case tok::starequal: Opc = BinaryOperator::MulAssign; break;
5272 case tok::slashequal: Opc = BinaryOperator::DivAssign; break;
5273 case tok::percentequal: Opc = BinaryOperator::RemAssign; break;
5274 case tok::plusequal: Opc = BinaryOperator::AddAssign; break;
5275 case tok::minusequal: Opc = BinaryOperator::SubAssign; break;
5276 case tok::lesslessequal: Opc = BinaryOperator::ShlAssign; break;
5277 case tok::greatergreaterequal: Opc = BinaryOperator::ShrAssign; break;
5278 case tok::ampequal: Opc = BinaryOperator::AndAssign; break;
5279 case tok::caretequal: Opc = BinaryOperator::XorAssign; break;
5280 case tok::pipeequal: Opc = BinaryOperator::OrAssign; break;
5281 case tok::comma: Opc = BinaryOperator::Comma; break;
5282 }
5283 return Opc;
5284}
5285
5286static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode(
5287 tok::TokenKind Kind) {
5288 UnaryOperator::Opcode Opc;
5289 switch (Kind) {
5290 default: assert(0 && "Unknown unary op!");
5291 case tok::plusplus: Opc = UnaryOperator::PreInc; break;
5292 case tok::minusminus: Opc = UnaryOperator::PreDec; break;
5293 case tok::amp: Opc = UnaryOperator::AddrOf; break;
5294 case tok::star: Opc = UnaryOperator::Deref; break;
5295 case tok::plus: Opc = UnaryOperator::Plus; break;
5296 case tok::minus: Opc = UnaryOperator::Minus; break;
5297 case tok::tilde: Opc = UnaryOperator::Not; break;
5298 case tok::exclaim: Opc = UnaryOperator::LNot; break;
Reid Spencer5f016e22007-07-11 17:01:13 +00005299 case tok::kw___real: Opc = UnaryOperator::Real; break;
5300 case tok::kw___imag: Opc = UnaryOperator::Imag; break;
5301 case tok::kw___extension__: Opc = UnaryOperator::Extension; break;
5302 }
5303 return Opc;
5304}
5305
Douglas Gregoreaebc752008-11-06 23:29:22 +00005306/// CreateBuiltinBinOp - Creates a new built-in binary operation with
5307/// operator @p Opc at location @c TokLoc. This routine only supports
5308/// built-in operations; ActOnBinOp handles overloaded operators.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00005309Action::OwningExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
5310 unsigned Op,
5311 Expr *lhs, Expr *rhs) {
Eli Friedmanab3a8522009-03-28 01:22:36 +00005312 QualType ResultTy; // Result type of the binary operator.
Douglas Gregoreaebc752008-11-06 23:29:22 +00005313 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)Op;
Eli Friedmanab3a8522009-03-28 01:22:36 +00005314 // The following two variables are used for compound assignment operators
5315 QualType CompLHSTy; // Type of LHS after promotions for computation
5316 QualType CompResultTy; // Type of computation result
Douglas Gregoreaebc752008-11-06 23:29:22 +00005317
5318 switch (Opc) {
Douglas Gregoreaebc752008-11-06 23:29:22 +00005319 case BinaryOperator::Assign:
5320 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType());
5321 break;
Sebastian Redl22460502009-02-07 00:15:38 +00005322 case BinaryOperator::PtrMemD:
5323 case BinaryOperator::PtrMemI:
5324 ResultTy = CheckPointerToMemberOperands(lhs, rhs, OpLoc,
5325 Opc == BinaryOperator::PtrMemI);
5326 break;
5327 case BinaryOperator::Mul:
Douglas Gregoreaebc752008-11-06 23:29:22 +00005328 case BinaryOperator::Div:
5329 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc);
5330 break;
5331 case BinaryOperator::Rem:
5332 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc);
5333 break;
5334 case BinaryOperator::Add:
5335 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc);
5336 break;
5337 case BinaryOperator::Sub:
5338 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc);
5339 break;
Sebastian Redl22460502009-02-07 00:15:38 +00005340 case BinaryOperator::Shl:
Douglas Gregoreaebc752008-11-06 23:29:22 +00005341 case BinaryOperator::Shr:
5342 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc);
5343 break;
5344 case BinaryOperator::LE:
5345 case BinaryOperator::LT:
5346 case BinaryOperator::GE:
5347 case BinaryOperator::GT:
Douglas Gregora86b8322009-04-06 18:45:53 +00005348 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005349 break;
5350 case BinaryOperator::EQ:
5351 case BinaryOperator::NE:
Douglas Gregora86b8322009-04-06 18:45:53 +00005352 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005353 break;
5354 case BinaryOperator::And:
5355 case BinaryOperator::Xor:
5356 case BinaryOperator::Or:
5357 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc);
5358 break;
5359 case BinaryOperator::LAnd:
5360 case BinaryOperator::LOr:
5361 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc);
5362 break;
5363 case BinaryOperator::MulAssign:
5364 case BinaryOperator::DivAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005365 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true);
5366 CompLHSTy = CompResultTy;
5367 if (!CompResultTy.isNull())
5368 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005369 break;
5370 case BinaryOperator::RemAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005371 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true);
5372 CompLHSTy = CompResultTy;
5373 if (!CompResultTy.isNull())
5374 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005375 break;
5376 case BinaryOperator::AddAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005377 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy);
5378 if (!CompResultTy.isNull())
5379 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005380 break;
5381 case BinaryOperator::SubAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005382 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy);
5383 if (!CompResultTy.isNull())
5384 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005385 break;
5386 case BinaryOperator::ShlAssign:
5387 case BinaryOperator::ShrAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005388 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true);
5389 CompLHSTy = CompResultTy;
5390 if (!CompResultTy.isNull())
5391 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005392 break;
5393 case BinaryOperator::AndAssign:
5394 case BinaryOperator::XorAssign:
5395 case BinaryOperator::OrAssign:
Eli Friedmanab3a8522009-03-28 01:22:36 +00005396 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true);
5397 CompLHSTy = CompResultTy;
5398 if (!CompResultTy.isNull())
5399 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
Douglas Gregoreaebc752008-11-06 23:29:22 +00005400 break;
5401 case BinaryOperator::Comma:
5402 ResultTy = CheckCommaOperands(lhs, rhs, OpLoc);
5403 break;
5404 }
5405 if (ResultTy.isNull())
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00005406 return ExprError();
Eli Friedmanab3a8522009-03-28 01:22:36 +00005407 if (CompResultTy.isNull())
Steve Naroff6ece14c2009-01-21 00:14:39 +00005408 return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy, OpLoc));
5409 else
5410 return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy,
Eli Friedmanab3a8522009-03-28 01:22:36 +00005411 CompLHSTy, CompResultTy,
5412 OpLoc));
Douglas Gregoreaebc752008-11-06 23:29:22 +00005413}
5414
Sebastian Redlaee3c932009-10-27 12:10:02 +00005415/// SuggestParentheses - Emit a diagnostic together with a fixit hint that wraps
5416/// ParenRange in parentheses.
Sebastian Redl6b169ac2009-10-26 17:01:32 +00005417static void SuggestParentheses(Sema &Self, SourceLocation Loc,
5418 const PartialDiagnostic &PD,
5419 SourceRange ParenRange)
5420{
5421 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd());
5422 if (!ParenRange.getEnd().isFileID() || EndLoc.isInvalid()) {
5423 // We can't display the parentheses, so just dig the
5424 // warning/error and return.
5425 Self.Diag(Loc, PD);
5426 return;
5427 }
5428
5429 Self.Diag(Loc, PD)
5430 << CodeModificationHint::CreateInsertion(ParenRange.getBegin(), "(")
5431 << CodeModificationHint::CreateInsertion(EndLoc, ")");
5432}
5433
Sebastian Redlaee3c932009-10-27 12:10:02 +00005434/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
5435/// operators are mixed in a way that suggests that the programmer forgot that
5436/// comparison operators have higher precedence. The most typical example of
5437/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005438static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperator::Opcode Opc,
5439 SourceLocation OpLoc,Expr *lhs,Expr *rhs){
Sebastian Redlaee3c932009-10-27 12:10:02 +00005440 typedef BinaryOperator BinOp;
5441 BinOp::Opcode lhsopc = static_cast<BinOp::Opcode>(-1),
5442 rhsopc = static_cast<BinOp::Opcode>(-1);
5443 if (BinOp *BO = dyn_cast<BinOp>(lhs))
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005444 lhsopc = BO->getOpcode();
Sebastian Redlaee3c932009-10-27 12:10:02 +00005445 if (BinOp *BO = dyn_cast<BinOp>(rhs))
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005446 rhsopc = BO->getOpcode();
5447
5448 // Subs are not binary operators.
5449 if (lhsopc == -1 && rhsopc == -1)
5450 return;
5451
5452 // Bitwise operations are sometimes used as eager logical ops.
5453 // Don't diagnose this.
Sebastian Redlaee3c932009-10-27 12:10:02 +00005454 if ((BinOp::isComparisonOp(lhsopc) || BinOp::isBitwiseOp(lhsopc)) &&
5455 (BinOp::isComparisonOp(rhsopc) || BinOp::isBitwiseOp(rhsopc)))
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005456 return;
5457
Sebastian Redlaee3c932009-10-27 12:10:02 +00005458 if (BinOp::isComparisonOp(lhsopc))
Sebastian Redl6b169ac2009-10-26 17:01:32 +00005459 SuggestParentheses(Self, OpLoc,
5460 PDiag(diag::warn_precedence_bitwise_rel)
Sebastian Redlaee3c932009-10-27 12:10:02 +00005461 << SourceRange(lhs->getLocStart(), OpLoc)
5462 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(lhsopc),
5463 SourceRange(cast<BinOp>(lhs)->getRHS()->getLocStart(), rhs->getLocEnd()));
5464 else if (BinOp::isComparisonOp(rhsopc))
Sebastian Redl6b169ac2009-10-26 17:01:32 +00005465 SuggestParentheses(Self, OpLoc,
5466 PDiag(diag::warn_precedence_bitwise_rel)
Sebastian Redlaee3c932009-10-27 12:10:02 +00005467 << SourceRange(OpLoc, rhs->getLocEnd())
5468 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(rhsopc),
5469 SourceRange(lhs->getLocEnd(), cast<BinOp>(rhs)->getLHS()->getLocStart()));
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005470}
5471
5472/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
5473/// precedence. This currently diagnoses only "arg1 'bitwise' arg2 'eq' arg3".
5474/// But it could also warn about arg1 && arg2 || arg3, as GCC 4.3+ does.
5475static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperator::Opcode Opc,
5476 SourceLocation OpLoc, Expr *lhs, Expr *rhs){
Sebastian Redlaee3c932009-10-27 12:10:02 +00005477 if (BinaryOperator::isBitwiseOp(Opc))
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005478 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, lhs, rhs);
5479}
5480
Reid Spencer5f016e22007-07-11 17:01:13 +00005481// Binary Operators. 'Tok' is the token for the operator.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00005482Action::OwningExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
5483 tok::TokenKind Kind,
5484 ExprArg LHS, ExprArg RHS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005485 BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind);
Anders Carlssone9146f22009-05-01 19:49:17 +00005486 Expr *lhs = LHS.takeAs<Expr>(), *rhs = RHS.takeAs<Expr>();
Reid Spencer5f016e22007-07-11 17:01:13 +00005487
Steve Narofff69936d2007-09-16 03:34:24 +00005488 assert((lhs != 0) && "ActOnBinOp(): missing left expression");
5489 assert((rhs != 0) && "ActOnBinOp(): missing right expression");
Reid Spencer5f016e22007-07-11 17:01:13 +00005490
Sebastian Redl9e1d29b2009-10-26 15:24:15 +00005491 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
5492 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, lhs, rhs);
5493
Douglas Gregor063daf62009-03-13 18:40:31 +00005494 if (getLangOptions().CPlusPlus &&
Mike Stump1eb44332009-09-09 15:08:12 +00005495 (lhs->getType()->isOverloadableType() ||
Douglas Gregor063daf62009-03-13 18:40:31 +00005496 rhs->getType()->isOverloadableType())) {
5497 // Find all of the overloaded operators visible from this
5498 // point. We perform both an operator-name lookup from the local
5499 // scope and an argument-dependent lookup based on the types of
5500 // the arguments.
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00005501 FunctionSet Functions;
Douglas Gregor063daf62009-03-13 18:40:31 +00005502 OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc);
5503 if (OverOp != OO_None) {
5504 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(),
5505 Functions);
5506 Expr *Args[2] = { lhs, rhs };
Mike Stump1eb44332009-09-09 15:08:12 +00005507 DeclarationName OpName
Douglas Gregor063daf62009-03-13 18:40:31 +00005508 = Context.DeclarationNames.getCXXOperatorName(OverOp);
Sebastian Redl644be852009-10-23 19:23:15 +00005509 ArgumentDependentLookup(OpName, /*Operator*/true, Args, 2, Functions);
Douglas Gregoreb8f3062008-11-12 17:17:38 +00005510 }
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00005511
Douglas Gregor063daf62009-03-13 18:40:31 +00005512 // Build the (potentially-overloaded, potentially-dependent)
5513 // binary operation.
5514 return CreateOverloadedBinOp(TokLoc, Opc, Functions, lhs, rhs);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00005515 }
5516
Douglas Gregoreaebc752008-11-06 23:29:22 +00005517 // Build a built-in binary operation.
5518 return CreateBuiltinBinOp(TokLoc, Opc, lhs, rhs);
Reid Spencer5f016e22007-07-11 17:01:13 +00005519}
5520
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005521Action::OwningExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00005522 unsigned OpcIn,
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005523 ExprArg InputArg) {
5524 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
Douglas Gregor74253732008-11-19 15:42:04 +00005525
Mike Stump390b4cc2009-05-16 07:39:55 +00005526 // FIXME: Input is modified below, but InputArg is not updated appropriately.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005527 Expr *Input = (Expr *)InputArg.get();
Reid Spencer5f016e22007-07-11 17:01:13 +00005528 QualType resultType;
5529 switch (Opc) {
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005530 case UnaryOperator::OffsetOf:
5531 assert(false && "Invalid unary operator");
5532 break;
5533
Reid Spencer5f016e22007-07-11 17:01:13 +00005534 case UnaryOperator::PreInc:
5535 case UnaryOperator::PreDec:
Eli Friedmande99a452009-07-22 22:25:00 +00005536 case UnaryOperator::PostInc:
5537 case UnaryOperator::PostDec:
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00005538 resultType = CheckIncrementDecrementOperand(Input, OpLoc,
Eli Friedmande99a452009-07-22 22:25:00 +00005539 Opc == UnaryOperator::PreInc ||
5540 Opc == UnaryOperator::PostInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00005541 break;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005542 case UnaryOperator::AddrOf:
Reid Spencer5f016e22007-07-11 17:01:13 +00005543 resultType = CheckAddressOfOperand(Input, OpLoc);
5544 break;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005545 case UnaryOperator::Deref:
Steve Naroff1ca9b112007-12-18 04:06:57 +00005546 DefaultFunctionArrayConversion(Input);
Reid Spencer5f016e22007-07-11 17:01:13 +00005547 resultType = CheckIndirectionOperand(Input, OpLoc);
5548 break;
5549 case UnaryOperator::Plus:
5550 case UnaryOperator::Minus:
Steve Naroffc80b4ee2007-07-16 21:54:35 +00005551 UsualUnaryConversions(Input);
5552 resultType = Input->getType();
Sebastian Redl28507842009-02-26 14:39:58 +00005553 if (resultType->isDependentType())
5554 break;
Douglas Gregor74253732008-11-19 15:42:04 +00005555 if (resultType->isArithmeticType()) // C99 6.5.3.3p1
5556 break;
5557 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7
5558 resultType->isEnumeralType())
5559 break;
5560 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6
5561 Opc == UnaryOperator::Plus &&
5562 resultType->isPointerType())
5563 break;
5564
Sebastian Redl0eb23302009-01-19 00:08:26 +00005565 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
5566 << resultType << Input->getSourceRange());
Reid Spencer5f016e22007-07-11 17:01:13 +00005567 case UnaryOperator::Not: // bitwise complement
Steve Naroffc80b4ee2007-07-16 21:54:35 +00005568 UsualUnaryConversions(Input);
5569 resultType = Input->getType();
Sebastian Redl28507842009-02-26 14:39:58 +00005570 if (resultType->isDependentType())
5571 break;
Chris Lattner02a65142008-07-25 23:52:49 +00005572 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
5573 if (resultType->isComplexType() || resultType->isComplexIntegerType())
5574 // C99 does not support '~' for complex conjugation.
Chris Lattnerd3a94e22008-11-20 06:06:08 +00005575 Diag(OpLoc, diag::ext_integer_complement_complex)
Chris Lattnerd1625842008-11-24 06:25:27 +00005576 << resultType << Input->getSourceRange();
Chris Lattner02a65142008-07-25 23:52:49 +00005577 else if (!resultType->isIntegerType())
Sebastian Redl0eb23302009-01-19 00:08:26 +00005578 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
5579 << resultType << Input->getSourceRange());
Reid Spencer5f016e22007-07-11 17:01:13 +00005580 break;
5581 case UnaryOperator::LNot: // logical negation
5582 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
Steve Naroffc80b4ee2007-07-16 21:54:35 +00005583 DefaultFunctionArrayConversion(Input);
5584 resultType = Input->getType();
Sebastian Redl28507842009-02-26 14:39:58 +00005585 if (resultType->isDependentType())
5586 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00005587 if (!resultType->isScalarType()) // C99 6.5.3.3p1
Sebastian Redl0eb23302009-01-19 00:08:26 +00005588 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
5589 << resultType << Input->getSourceRange());
Reid Spencer5f016e22007-07-11 17:01:13 +00005590 // LNot always has type int. C99 6.5.3.3p5.
Sebastian Redl0eb23302009-01-19 00:08:26 +00005591 // In C++, it's bool. C++ 5.3.1p8
5592 resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy;
Reid Spencer5f016e22007-07-11 17:01:13 +00005593 break;
Chris Lattnerdbb36972007-08-24 21:16:53 +00005594 case UnaryOperator::Real:
Chris Lattnerdbb36972007-08-24 21:16:53 +00005595 case UnaryOperator::Imag:
Chris Lattnerba27e2a2009-02-17 08:12:06 +00005596 resultType = CheckRealImagOperand(Input, OpLoc, Opc == UnaryOperator::Real);
Chris Lattnerdbb36972007-08-24 21:16:53 +00005597 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00005598 case UnaryOperator::Extension:
Reid Spencer5f016e22007-07-11 17:01:13 +00005599 resultType = Input->getType();
5600 break;
5601 }
5602 if (resultType.isNull())
Sebastian Redl0eb23302009-01-19 00:08:26 +00005603 return ExprError();
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005604
5605 InputArg.release();
Steve Naroff6ece14c2009-01-21 00:14:39 +00005606 return Owned(new (Context) UnaryOperator(Input, Opc, resultType, OpLoc));
Reid Spencer5f016e22007-07-11 17:01:13 +00005607}
5608
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005609// Unary Operators. 'Tok' is the token for the operator.
5610Action::OwningExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5611 tok::TokenKind Op, ExprArg input) {
5612 Expr *Input = (Expr*)input.get();
5613 UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op);
5614
5615 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType()) {
5616 // Find all of the overloaded operators visible from this
5617 // point. We perform both an operator-name lookup from the local
5618 // scope and an argument-dependent lookup based on the types of
5619 // the arguments.
5620 FunctionSet Functions;
5621 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
5622 if (OverOp != OO_None) {
5623 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
5624 Functions);
Mike Stump1eb44332009-09-09 15:08:12 +00005625 DeclarationName OpName
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005626 = Context.DeclarationNames.getCXXOperatorName(OverOp);
Sebastian Redl644be852009-10-23 19:23:15 +00005627 ArgumentDependentLookup(OpName, /*Operator*/true, &Input, 1, Functions);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00005628 }
5629
5630 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(input));
5631 }
5632
5633 return CreateBuiltinUnaryOp(OpLoc, Opc, move(input));
5634}
5635
Steve Naroff1b273c42007-09-16 14:56:35 +00005636/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00005637Sema::OwningExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
5638 SourceLocation LabLoc,
5639 IdentifierInfo *LabelII) {
Reid Spencer5f016e22007-07-11 17:01:13 +00005640 // Look up the record for this label identifier.
Chris Lattnerea29a3a2009-04-18 20:01:55 +00005641 LabelStmt *&LabelDecl = getLabelMap()[LabelII];
Mike Stumpeed9cac2009-02-19 03:04:26 +00005642
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00005643 // If we haven't seen this label yet, create a forward reference. It
5644 // will be validated and/or cleaned up in ActOnFinishFunctionBody.
Steve Naroffcaaacec2009-03-13 15:38:40 +00005645 if (LabelDecl == 0)
Steve Naroff6ece14c2009-01-21 00:14:39 +00005646 LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005647
Reid Spencer5f016e22007-07-11 17:01:13 +00005648 // Create the AST node. The address of a label always has type 'void*'.
Sebastian Redlf53597f2009-03-15 17:47:39 +00005649 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
5650 Context.getPointerType(Context.VoidTy)));
Reid Spencer5f016e22007-07-11 17:01:13 +00005651}
5652
Sebastian Redlf53597f2009-03-15 17:47:39 +00005653Sema::OwningExprResult
5654Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtArg substmt,
5655 SourceLocation RPLoc) { // "({..})"
5656 Stmt *SubStmt = static_cast<Stmt*>(substmt.get());
Chris Lattnerab18c4c2007-07-24 16:58:17 +00005657 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
5658 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
5659
Eli Friedmandca2b732009-01-24 23:09:00 +00005660 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
Chris Lattner4a049f02009-04-25 19:11:05 +00005661 if (isFileScope)
Sebastian Redlf53597f2009-03-15 17:47:39 +00005662 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
Eli Friedmandca2b732009-01-24 23:09:00 +00005663
Chris Lattnerab18c4c2007-07-24 16:58:17 +00005664 // FIXME: there are a variety of strange constraints to enforce here, for
5665 // example, it is not possible to goto into a stmt expression apparently.
5666 // More semantic analysis is needed.
Mike Stumpeed9cac2009-02-19 03:04:26 +00005667
Chris Lattnerab18c4c2007-07-24 16:58:17 +00005668 // If there are sub stmts in the compound stmt, take the type of the last one
5669 // as the type of the stmtexpr.
5670 QualType Ty = Context.VoidTy;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005671
Chris Lattner611b2ec2008-07-26 19:51:01 +00005672 if (!Compound->body_empty()) {
5673 Stmt *LastStmt = Compound->body_back();
5674 // If LastStmt is a label, skip down through into the body.
5675 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt))
5676 LastStmt = Label->getSubStmt();
Mike Stumpeed9cac2009-02-19 03:04:26 +00005677
Chris Lattner611b2ec2008-07-26 19:51:01 +00005678 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt))
Chris Lattnerab18c4c2007-07-24 16:58:17 +00005679 Ty = LastExpr->getType();
Chris Lattner611b2ec2008-07-26 19:51:01 +00005680 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00005681
Eli Friedmanb1d796d2009-03-23 00:24:07 +00005682 // FIXME: Check that expression type is complete/non-abstract; statement
5683 // expressions are not lvalues.
5684
Sebastian Redlf53597f2009-03-15 17:47:39 +00005685 substmt.release();
5686 return Owned(new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc));
Chris Lattnerab18c4c2007-07-24 16:58:17 +00005687}
Steve Naroffd34e9152007-08-01 22:05:33 +00005688
Sebastian Redlf53597f2009-03-15 17:47:39 +00005689Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
5690 SourceLocation BuiltinLoc,
5691 SourceLocation TypeLoc,
5692 TypeTy *argty,
5693 OffsetOfComponent *CompPtr,
5694 unsigned NumComponents,
5695 SourceLocation RPLoc) {
5696 // FIXME: This function leaks all expressions in the offset components on
5697 // error.
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00005698 // FIXME: Preserve type source info.
5699 QualType ArgTy = GetTypeFromParser(argty);
Chris Lattner73d0d4f2007-08-30 17:45:32 +00005700 assert(!ArgTy.isNull() && "Missing type argument!");
Mike Stumpeed9cac2009-02-19 03:04:26 +00005701
Sebastian Redl28507842009-02-26 14:39:58 +00005702 bool Dependent = ArgTy->isDependentType();
5703
Chris Lattner73d0d4f2007-08-30 17:45:32 +00005704 // We must have at least one component that refers to the type, and the first
5705 // one is known to be a field designator. Verify that the ArgTy represents
5706 // a struct/union/class.
Sebastian Redl28507842009-02-26 14:39:58 +00005707 if (!Dependent && !ArgTy->isRecordType())
Sebastian Redlf53597f2009-03-15 17:47:39 +00005708 return ExprError(Diag(TypeLoc, diag::err_offsetof_record_type) << ArgTy);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005709
Eli Friedmanb1d796d2009-03-23 00:24:07 +00005710 // FIXME: Type must be complete per C99 7.17p3 because a declaring a variable
5711 // with an incomplete type would be illegal.
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00005712
Eli Friedman35183ac2009-02-27 06:44:11 +00005713 // Otherwise, create a null pointer as the base, and iteratively process
5714 // the offsetof designators.
5715 QualType ArgTyPtr = Context.getPointerType(ArgTy);
5716 Expr* Res = new (Context) ImplicitValueInitExpr(ArgTyPtr);
Sebastian Redlf53597f2009-03-15 17:47:39 +00005717 Res = new (Context) UnaryOperator(Res, UnaryOperator::Deref,
Eli Friedman35183ac2009-02-27 06:44:11 +00005718 ArgTy, SourceLocation());
Eli Friedman1d242592009-01-26 01:33:06 +00005719
Chris Lattner9e2b75c2007-08-31 21:49:13 +00005720 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
5721 // GCC extension, diagnose them.
Eli Friedman35183ac2009-02-27 06:44:11 +00005722 // FIXME: This diagnostic isn't actually visible because the location is in
5723 // a system header!
Chris Lattner9e2b75c2007-08-31 21:49:13 +00005724 if (NumComponents != 1)
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00005725 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
5726 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005727
Sebastian Redl28507842009-02-26 14:39:58 +00005728 if (!Dependent) {
Eli Friedmanc0d600c2009-05-03 21:22:18 +00005729 bool DidWarnAboutNonPOD = false;
Mike Stump1eb44332009-09-09 15:08:12 +00005730
Sebastian Redl28507842009-02-26 14:39:58 +00005731 // FIXME: Dependent case loses a lot of information here. And probably
5732 // leaks like a sieve.
5733 for (unsigned i = 0; i != NumComponents; ++i) {
5734 const OffsetOfComponent &OC = CompPtr[i];
5735 if (OC.isBrackets) {
5736 // Offset of an array sub-field. TODO: Should we allow vector elements?
5737 const ArrayType *AT = Context.getAsArrayType(Res->getType());
5738 if (!AT) {
5739 Res->Destroy(Context);
Sebastian Redlf53597f2009-03-15 17:47:39 +00005740 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
5741 << Res->getType());
Sebastian Redl28507842009-02-26 14:39:58 +00005742 }
5743
5744 // FIXME: C++: Verify that operator[] isn't overloaded.
5745
Eli Friedman35183ac2009-02-27 06:44:11 +00005746 // Promote the array so it looks more like a normal array subscript
5747 // expression.
5748 DefaultFunctionArrayConversion(Res);
5749
Sebastian Redl28507842009-02-26 14:39:58 +00005750 // C99 6.5.2.1p1
5751 Expr *Idx = static_cast<Expr*>(OC.U.E);
Sebastian Redlf53597f2009-03-15 17:47:39 +00005752 // FIXME: Leaks Res
Sebastian Redl28507842009-02-26 14:39:58 +00005753 if (!Idx->isTypeDependent() && !Idx->getType()->isIntegerType())
Sebastian Redlf53597f2009-03-15 17:47:39 +00005754 return ExprError(Diag(Idx->getLocStart(),
Chris Lattner338395d2009-04-25 22:50:55 +00005755 diag::err_typecheck_subscript_not_integer)
Sebastian Redlf53597f2009-03-15 17:47:39 +00005756 << Idx->getSourceRange());
Sebastian Redl28507842009-02-26 14:39:58 +00005757
5758 Res = new (Context) ArraySubscriptExpr(Res, Idx, AT->getElementType(),
5759 OC.LocEnd);
5760 continue;
Chris Lattner73d0d4f2007-08-30 17:45:32 +00005761 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00005762
Ted Kremenek6217b802009-07-29 21:53:49 +00005763 const RecordType *RC = Res->getType()->getAs<RecordType>();
Sebastian Redl28507842009-02-26 14:39:58 +00005764 if (!RC) {
5765 Res->Destroy(Context);
Sebastian Redlf53597f2009-03-15 17:47:39 +00005766 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
5767 << Res->getType());
Sebastian Redl28507842009-02-26 14:39:58 +00005768 }
Chris Lattner704fe352007-08-30 17:59:59 +00005769
Sebastian Redl28507842009-02-26 14:39:58 +00005770 // Get the decl corresponding to this.
5771 RecordDecl *RD = RC->getDecl();
Anders Carlsson6d7f1492009-05-01 23:20:30 +00005772 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
Anders Carlsson5992e4a2009-05-02 18:36:10 +00005773 if (!CRD->isPOD() && !DidWarnAboutNonPOD) {
Anders Carlssonf9b8bc62009-05-02 17:45:47 +00005774 ExprError(Diag(BuiltinLoc, diag::warn_offsetof_non_pod_type)
5775 << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
5776 << Res->getType());
Anders Carlsson5992e4a2009-05-02 18:36:10 +00005777 DidWarnAboutNonPOD = true;
5778 }
Anders Carlsson6d7f1492009-05-01 23:20:30 +00005779 }
Mike Stump1eb44332009-09-09 15:08:12 +00005780
John McCallf36e02d2009-10-09 21:13:30 +00005781 LookupResult R;
5782 LookupQualifiedName(R, RD, OC.U.IdentInfo, LookupMemberName);
5783
Sebastian Redl28507842009-02-26 14:39:58 +00005784 FieldDecl *MemberDecl
John McCallf36e02d2009-10-09 21:13:30 +00005785 = dyn_cast_or_null<FieldDecl>(R.getAsSingleDecl(Context));
Sebastian Redlf53597f2009-03-15 17:47:39 +00005786 // FIXME: Leaks Res
Sebastian Redl28507842009-02-26 14:39:58 +00005787 if (!MemberDecl)
Douglas Gregor3f093272009-10-13 21:16:44 +00005788 return ExprError(Diag(BuiltinLoc, diag::err_no_member)
5789 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, OC.LocEnd));
Mike Stumpeed9cac2009-02-19 03:04:26 +00005790
Sebastian Redl28507842009-02-26 14:39:58 +00005791 // FIXME: C++: Verify that MemberDecl isn't a static field.
5792 // FIXME: Verify that MemberDecl isn't a bitfield.
Eli Friedmane9356962009-04-26 20:50:44 +00005793 if (cast<RecordDecl>(MemberDecl->getDeclContext())->isAnonymousStructOrUnion()) {
Anders Carlssonf1b1d592009-05-01 19:30:39 +00005794 Res = BuildAnonymousStructUnionMemberReference(
5795 SourceLocation(), MemberDecl, Res, SourceLocation()).takeAs<Expr>();
Eli Friedmane9356962009-04-26 20:50:44 +00005796 } else {
5797 // MemberDecl->getType() doesn't get the right qualifiers, but it
5798 // doesn't matter here.
5799 Res = new (Context) MemberExpr(Res, false, MemberDecl, OC.LocEnd,
5800 MemberDecl->getType().getNonReferenceType());
5801 }
Sebastian Redl28507842009-02-26 14:39:58 +00005802 }
Chris Lattner73d0d4f2007-08-30 17:45:32 +00005803 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00005804
Sebastian Redlf53597f2009-03-15 17:47:39 +00005805 return Owned(new (Context) UnaryOperator(Res, UnaryOperator::OffsetOf,
5806 Context.getSizeType(), BuiltinLoc));
Chris Lattner73d0d4f2007-08-30 17:45:32 +00005807}
5808
5809
Sebastian Redlf53597f2009-03-15 17:47:39 +00005810Sema::OwningExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
5811 TypeTy *arg1,TypeTy *arg2,
5812 SourceLocation RPLoc) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00005813 // FIXME: Preserve type source info.
5814 QualType argT1 = GetTypeFromParser(arg1);
5815 QualType argT2 = GetTypeFromParser(arg2);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005816
Steve Naroffd34e9152007-08-01 22:05:33 +00005817 assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)");
Mike Stumpeed9cac2009-02-19 03:04:26 +00005818
Douglas Gregorc12a9c52009-05-19 22:28:02 +00005819 if (getLangOptions().CPlusPlus) {
5820 Diag(BuiltinLoc, diag::err_types_compatible_p_in_cplusplus)
5821 << SourceRange(BuiltinLoc, RPLoc);
5822 return ExprError();
5823 }
5824
Sebastian Redlf53597f2009-03-15 17:47:39 +00005825 return Owned(new (Context) TypesCompatibleExpr(Context.IntTy, BuiltinLoc,
5826 argT1, argT2, RPLoc));
Steve Naroffd34e9152007-08-01 22:05:33 +00005827}
5828
Sebastian Redlf53597f2009-03-15 17:47:39 +00005829Sema::OwningExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
5830 ExprArg cond,
5831 ExprArg expr1, ExprArg expr2,
5832 SourceLocation RPLoc) {
5833 Expr *CondExpr = static_cast<Expr*>(cond.get());
5834 Expr *LHSExpr = static_cast<Expr*>(expr1.get());
5835 Expr *RHSExpr = static_cast<Expr*>(expr2.get());
Mike Stumpeed9cac2009-02-19 03:04:26 +00005836
Steve Naroffd04fdd52007-08-03 21:21:27 +00005837 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
5838
Sebastian Redl28507842009-02-26 14:39:58 +00005839 QualType resType;
Douglas Gregorce940492009-09-25 04:25:58 +00005840 bool ValueDependent = false;
Douglas Gregorc9ecc572009-05-19 22:43:30 +00005841 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
Sebastian Redl28507842009-02-26 14:39:58 +00005842 resType = Context.DependentTy;
Douglas Gregorce940492009-09-25 04:25:58 +00005843 ValueDependent = true;
Sebastian Redl28507842009-02-26 14:39:58 +00005844 } else {
5845 // The conditional expression is required to be a constant expression.
5846 llvm::APSInt condEval(32);
5847 SourceLocation ExpLoc;
5848 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
Sebastian Redlf53597f2009-03-15 17:47:39 +00005849 return ExprError(Diag(ExpLoc,
5850 diag::err_typecheck_choose_expr_requires_constant)
5851 << CondExpr->getSourceRange());
Steve Naroffd04fdd52007-08-03 21:21:27 +00005852
Sebastian Redl28507842009-02-26 14:39:58 +00005853 // If the condition is > zero, then the AST type is the same as the LSHExpr.
5854 resType = condEval.getZExtValue() ? LHSExpr->getType() : RHSExpr->getType();
Douglas Gregorce940492009-09-25 04:25:58 +00005855 ValueDependent = condEval.getZExtValue() ? LHSExpr->isValueDependent()
5856 : RHSExpr->isValueDependent();
Sebastian Redl28507842009-02-26 14:39:58 +00005857 }
5858
Sebastian Redlf53597f2009-03-15 17:47:39 +00005859 cond.release(); expr1.release(); expr2.release();
5860 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
Douglas Gregorce940492009-09-25 04:25:58 +00005861 resType, RPLoc,
5862 resType->isDependentType(),
5863 ValueDependent));
Steve Naroffd04fdd52007-08-03 21:21:27 +00005864}
5865
Steve Naroff4eb206b2008-09-03 18:15:37 +00005866//===----------------------------------------------------------------------===//
5867// Clang Extensions.
5868//===----------------------------------------------------------------------===//
5869
5870/// ActOnBlockStart - This callback is invoked when a block literal is started.
Steve Naroff090276f2008-10-10 01:28:17 +00005871void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00005872 // Analyze block parameters.
5873 BlockSemaInfo *BSI = new BlockSemaInfo();
Mike Stumpeed9cac2009-02-19 03:04:26 +00005874
Steve Naroff4eb206b2008-09-03 18:15:37 +00005875 // Add BSI to CurBlock.
5876 BSI->PrevBlockInfo = CurBlock;
5877 CurBlock = BSI;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005878
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +00005879 BSI->ReturnType = QualType();
Steve Naroff4eb206b2008-09-03 18:15:37 +00005880 BSI->TheScope = BlockScope;
Mike Stumpb83d2872009-02-19 22:01:56 +00005881 BSI->hasBlockDeclRefExprs = false;
Daniel Dunbar1d2154c2009-07-29 01:59:17 +00005882 BSI->hasPrototype = false;
Chris Lattner17a78302009-04-19 05:28:12 +00005883 BSI->SavedFunctionNeedsScopeChecking = CurFunctionNeedsScopeChecking;
5884 CurFunctionNeedsScopeChecking = false;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005885
Steve Naroff090276f2008-10-10 01:28:17 +00005886 BSI->TheDecl = BlockDecl::Create(Context, CurContext, CaretLoc);
Douglas Gregor44b43212008-12-11 16:49:14 +00005887 PushDeclContext(BlockScope, BSI->TheDecl);
Steve Naroff090276f2008-10-10 01:28:17 +00005888}
5889
Mike Stump98eb8a72009-02-04 22:31:32 +00005890void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
Mike Stumpaf199f32009-05-07 18:43:07 +00005891 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
Mike Stump98eb8a72009-02-04 22:31:32 +00005892
5893 if (ParamInfo.getNumTypeObjects() == 0
5894 || ParamInfo.getTypeObject(0).Kind != DeclaratorChunk::Function) {
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005895 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
Mike Stump98eb8a72009-02-04 22:31:32 +00005896 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5897
Mike Stump4eeab842009-04-28 01:10:27 +00005898 if (T->isArrayType()) {
5899 Diag(ParamInfo.getSourceRange().getBegin(),
5900 diag::err_block_returns_array);
5901 return;
5902 }
5903
Mike Stump98eb8a72009-02-04 22:31:32 +00005904 // The parameter list is optional, if there was none, assume ().
5905 if (!T->isFunctionType())
5906 T = Context.getFunctionType(T, NULL, 0, 0, 0);
5907
5908 CurBlock->hasPrototype = true;
5909 CurBlock->isVariadic = false;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00005910 // Check for a valid sentinel attribute on this block.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00005911 if (CurBlock->TheDecl->getAttr<SentinelAttr>()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005912 Diag(ParamInfo.getAttributes()->getLoc(),
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00005913 diag::warn_attribute_sentinel_not_variadic) << 1;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00005914 // FIXME: remove the attribute.
5915 }
John McCall183700f2009-09-21 23:43:11 +00005916 QualType RetTy = T.getTypePtr()->getAs<FunctionType>()->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +00005917
Chris Lattner9097af12009-04-11 19:27:54 +00005918 // Do not allow returning a objc interface by-value.
5919 if (RetTy->isObjCInterfaceType()) {
5920 Diag(ParamInfo.getSourceRange().getBegin(),
5921 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5922 return;
5923 }
Mike Stump98eb8a72009-02-04 22:31:32 +00005924 return;
5925 }
5926
Steve Naroff4eb206b2008-09-03 18:15:37 +00005927 // Analyze arguments to block.
5928 assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function &&
5929 "Not a function declarator!");
5930 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005931
Steve Naroff090276f2008-10-10 01:28:17 +00005932 CurBlock->hasPrototype = FTI.hasPrototype;
5933 CurBlock->isVariadic = true;
Mike Stumpeed9cac2009-02-19 03:04:26 +00005934
Steve Naroff4eb206b2008-09-03 18:15:37 +00005935 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
5936 // no arguments, not a function that takes a single void argument.
5937 if (FTI.hasPrototype &&
5938 FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
Chris Lattnerb28317a2009-03-28 19:18:32 +00005939 (!FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType().getCVRQualifiers()&&
5940 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType())) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00005941 // empty arg list, don't push any params.
Steve Naroff090276f2008-10-10 01:28:17 +00005942 CurBlock->isVariadic = false;
Steve Naroff4eb206b2008-09-03 18:15:37 +00005943 } else if (FTI.hasPrototype) {
5944 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
Chris Lattnerb28317a2009-03-28 19:18:32 +00005945 CurBlock->Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>());
Steve Naroff090276f2008-10-10 01:28:17 +00005946 CurBlock->isVariadic = FTI.isVariadic;
Steve Naroff4eb206b2008-09-03 18:15:37 +00005947 }
Jay Foadbeaaccd2009-05-21 09:52:38 +00005948 CurBlock->TheDecl->setParams(Context, CurBlock->Params.data(),
Chris Lattner9097af12009-04-11 19:27:54 +00005949 CurBlock->Params.size());
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +00005950 CurBlock->TheDecl->setIsVariadic(CurBlock->isVariadic);
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00005951 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
Steve Naroff090276f2008-10-10 01:28:17 +00005952 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
5953 E = CurBlock->TheDecl->param_end(); AI != E; ++AI)
5954 // If this has an identifier, add it to the scope stack.
5955 if ((*AI)->getIdentifier())
5956 PushOnScopeChains(*AI, CurBlock->TheScope);
Chris Lattner9097af12009-04-11 19:27:54 +00005957
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00005958 // Check for a valid sentinel attribute on this block.
Mike Stump1eb44332009-09-09 15:08:12 +00005959 if (!CurBlock->isVariadic &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00005960 CurBlock->TheDecl->getAttr<SentinelAttr>()) {
Mike Stump1eb44332009-09-09 15:08:12 +00005961 Diag(ParamInfo.getAttributes()->getLoc(),
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00005962 diag::warn_attribute_sentinel_not_variadic) << 1;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00005963 // FIXME: remove the attribute.
5964 }
Mike Stump1eb44332009-09-09 15:08:12 +00005965
Chris Lattner9097af12009-04-11 19:27:54 +00005966 // Analyze the return type.
5967 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
John McCall183700f2009-09-21 23:43:11 +00005968 QualType RetTy = T->getAs<FunctionType>()->getResultType();
Mike Stump1eb44332009-09-09 15:08:12 +00005969
Chris Lattner9097af12009-04-11 19:27:54 +00005970 // Do not allow returning a objc interface by-value.
5971 if (RetTy->isObjCInterfaceType()) {
5972 Diag(ParamInfo.getSourceRange().getBegin(),
5973 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5974 } else if (!RetTy->isDependentType())
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +00005975 CurBlock->ReturnType = RetTy;
Steve Naroff4eb206b2008-09-03 18:15:37 +00005976}
5977
5978/// ActOnBlockError - If there is an error parsing a block, this callback
5979/// is invoked to pop the information about the block from the action impl.
5980void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
5981 // Ensure that CurBlock is deleted.
5982 llvm::OwningPtr<BlockSemaInfo> CC(CurBlock);
Mike Stumpeed9cac2009-02-19 03:04:26 +00005983
Chris Lattner17a78302009-04-19 05:28:12 +00005984 CurFunctionNeedsScopeChecking = CurBlock->SavedFunctionNeedsScopeChecking;
5985
Steve Naroff4eb206b2008-09-03 18:15:37 +00005986 // Pop off CurBlock, handle nested blocks.
Chris Lattner5c59e2b2009-04-21 22:38:46 +00005987 PopDeclContext();
Steve Naroff4eb206b2008-09-03 18:15:37 +00005988 CurBlock = CurBlock->PrevBlockInfo;
Steve Naroff4eb206b2008-09-03 18:15:37 +00005989 // FIXME: Delete the ParmVarDecl objects as well???
Steve Naroff4eb206b2008-09-03 18:15:37 +00005990}
5991
5992/// ActOnBlockStmtExpr - This is called when the body of a block statement
5993/// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00005994Sema::OwningExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
5995 StmtArg body, Scope *CurScope) {
Chris Lattner9af55002009-03-27 04:18:06 +00005996 // If blocks are disabled, emit an error.
5997 if (!LangOpts.Blocks)
5998 Diag(CaretLoc, diag::err_blocks_disable);
Mike Stump1eb44332009-09-09 15:08:12 +00005999
Steve Naroff4eb206b2008-09-03 18:15:37 +00006000 // Ensure that CurBlock is deleted.
6001 llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock);
Steve Naroff4eb206b2008-09-03 18:15:37 +00006002
Steve Naroff090276f2008-10-10 01:28:17 +00006003 PopDeclContext();
6004
Steve Naroff4eb206b2008-09-03 18:15:37 +00006005 // Pop off CurBlock, handle nested blocks.
6006 CurBlock = CurBlock->PrevBlockInfo;
Mike Stumpeed9cac2009-02-19 03:04:26 +00006007
Steve Naroff4eb206b2008-09-03 18:15:37 +00006008 QualType RetTy = Context.VoidTy;
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +00006009 if (!BSI->ReturnType.isNull())
6010 RetTy = BSI->ReturnType;
Mike Stumpeed9cac2009-02-19 03:04:26 +00006011
Steve Naroff4eb206b2008-09-03 18:15:37 +00006012 llvm::SmallVector<QualType, 8> ArgTypes;
6013 for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i)
6014 ArgTypes.push_back(BSI->Params[i]->getType());
Mike Stumpeed9cac2009-02-19 03:04:26 +00006015
Mike Stump56925862009-07-28 22:04:01 +00006016 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>();
Steve Naroff4eb206b2008-09-03 18:15:37 +00006017 QualType BlockTy;
6018 if (!BSI->hasPrototype)
Mike Stump56925862009-07-28 22:04:01 +00006019 BlockTy = Context.getFunctionType(RetTy, 0, 0, false, 0, false, false, 0, 0,
6020 NoReturn);
Steve Naroff4eb206b2008-09-03 18:15:37 +00006021 else
Jay Foadbeaaccd2009-05-21 09:52:38 +00006022 BlockTy = Context.getFunctionType(RetTy, ArgTypes.data(), ArgTypes.size(),
Mike Stump56925862009-07-28 22:04:01 +00006023 BSI->isVariadic, 0, false, false, 0, 0,
6024 NoReturn);
Mike Stumpeed9cac2009-02-19 03:04:26 +00006025
Eli Friedmanb1d796d2009-03-23 00:24:07 +00006026 // FIXME: Check that return/parameter types are complete/non-abstract
Douglas Gregore0762c92009-06-19 23:52:42 +00006027 DiagnoseUnusedParameters(BSI->Params.begin(), BSI->Params.end());
Steve Naroff4eb206b2008-09-03 18:15:37 +00006028 BlockTy = Context.getBlockPointerType(BlockTy);
Mike Stumpeed9cac2009-02-19 03:04:26 +00006029
Chris Lattner17a78302009-04-19 05:28:12 +00006030 // If needed, diagnose invalid gotos and switches in the block.
6031 if (CurFunctionNeedsScopeChecking)
6032 DiagnoseInvalidJumps(static_cast<CompoundStmt*>(body.get()));
6033 CurFunctionNeedsScopeChecking = BSI->SavedFunctionNeedsScopeChecking;
Mike Stump1eb44332009-09-09 15:08:12 +00006034
Anders Carlssone9146f22009-05-01 19:49:17 +00006035 BSI->TheDecl->setBody(body.takeAs<CompoundStmt>());
Mike Stump56925862009-07-28 22:04:01 +00006036 CheckFallThroughForBlock(BlockTy, BSI->TheDecl->getBody());
Sebastian Redlf53597f2009-03-15 17:47:39 +00006037 return Owned(new (Context) BlockExpr(BSI->TheDecl, BlockTy,
6038 BSI->hasBlockDeclRefExprs));
Steve Naroff4eb206b2008-09-03 18:15:37 +00006039}
6040
Sebastian Redlf53597f2009-03-15 17:47:39 +00006041Sema::OwningExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
6042 ExprArg expr, TypeTy *type,
6043 SourceLocation RPLoc) {
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +00006044 QualType T = GetTypeFromParser(type);
Chris Lattner0d20b8a2009-04-05 15:49:53 +00006045 Expr *E = static_cast<Expr*>(expr.get());
6046 Expr *OrigExpr = E;
Mike Stump1eb44332009-09-09 15:08:12 +00006047
Anders Carlsson7c50aca2007-10-15 20:28:48 +00006048 InitBuiltinVaListType();
Eli Friedmanc34bcde2008-08-09 23:32:40 +00006049
6050 // Get the va_list type
6051 QualType VaListType = Context.getBuiltinVaListType();
Eli Friedman5c091ba2009-05-16 12:46:54 +00006052 if (VaListType->isArrayType()) {
6053 // Deal with implicit array decay; for example, on x86-64,
6054 // va_list is an array, but it's supposed to decay to
6055 // a pointer for va_arg.
Eli Friedmanc34bcde2008-08-09 23:32:40 +00006056 VaListType = Context.getArrayDecayedType(VaListType);
Eli Friedman5c091ba2009-05-16 12:46:54 +00006057 // Make sure the input expression also decays appropriately.
6058 UsualUnaryConversions(E);
6059 } else {
6060 // Otherwise, the va_list argument must be an l-value because
6061 // it is modified by va_arg.
Mike Stump1eb44332009-09-09 15:08:12 +00006062 if (!E->isTypeDependent() &&
Douglas Gregordd027302009-05-19 23:10:31 +00006063 CheckForModifiableLvalue(E, BuiltinLoc, *this))
Eli Friedman5c091ba2009-05-16 12:46:54 +00006064 return ExprError();
6065 }
Eli Friedmanc34bcde2008-08-09 23:32:40 +00006066
Douglas Gregordd027302009-05-19 23:10:31 +00006067 if (!E->isTypeDependent() &&
6068 !Context.hasSameType(VaListType, E->getType())) {
Sebastian Redlf53597f2009-03-15 17:47:39 +00006069 return ExprError(Diag(E->getLocStart(),
6070 diag::err_first_argument_to_va_arg_not_of_type_va_list)
Chris Lattner0d20b8a2009-04-05 15:49:53 +00006071 << OrigExpr->getType() << E->getSourceRange());
Chris Lattner9dc8f192009-04-05 00:59:53 +00006072 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00006073
Eli Friedmanb1d796d2009-03-23 00:24:07 +00006074 // FIXME: Check that type is complete/non-abstract
Anders Carlsson7c50aca2007-10-15 20:28:48 +00006075 // FIXME: Warn if a non-POD type is passed in.
Mike Stumpeed9cac2009-02-19 03:04:26 +00006076
Sebastian Redlf53597f2009-03-15 17:47:39 +00006077 expr.release();
6078 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, T.getNonReferenceType(),
6079 RPLoc));
Anders Carlsson7c50aca2007-10-15 20:28:48 +00006080}
6081
Sebastian Redlf53597f2009-03-15 17:47:39 +00006082Sema::OwningExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
Douglas Gregor2d8b2732008-11-29 04:51:27 +00006083 // The type of __null will be int or long, depending on the size of
6084 // pointers on the target.
6085 QualType Ty;
6086 if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth())
6087 Ty = Context.IntTy;
6088 else
6089 Ty = Context.LongTy;
6090
Sebastian Redlf53597f2009-03-15 17:47:39 +00006091 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
Douglas Gregor2d8b2732008-11-29 04:51:27 +00006092}
6093
Chris Lattner5cf216b2008-01-04 18:04:52 +00006094bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
6095 SourceLocation Loc,
6096 QualType DstType, QualType SrcType,
6097 Expr *SrcExpr, const char *Flavor) {
6098 // Decode the result (notice that AST's are still created for extensions).
6099 bool isInvalid = false;
6100 unsigned DiagKind;
6101 switch (ConvTy) {
6102 default: assert(0 && "Unknown conversion type");
6103 case Compatible: return false;
Chris Lattnerb7b61152008-01-04 18:22:42 +00006104 case PointerToInt:
Chris Lattner5cf216b2008-01-04 18:04:52 +00006105 DiagKind = diag::ext_typecheck_convert_pointer_int;
6106 break;
Chris Lattnerb7b61152008-01-04 18:22:42 +00006107 case IntToPointer:
6108 DiagKind = diag::ext_typecheck_convert_int_pointer;
6109 break;
Chris Lattner5cf216b2008-01-04 18:04:52 +00006110 case IncompatiblePointer:
6111 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
6112 break;
Eli Friedmanf05c05d2009-03-22 23:59:44 +00006113 case IncompatiblePointerSign:
6114 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
6115 break;
Chris Lattner5cf216b2008-01-04 18:04:52 +00006116 case FunctionVoidPointer:
6117 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
6118 break;
6119 case CompatiblePointerDiscardsQualifiers:
Douglas Gregor77a52232008-09-12 00:47:35 +00006120 // If the qualifiers lost were because we were applying the
6121 // (deprecated) C++ conversion from a string literal to a char*
6122 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
6123 // Ideally, this check would be performed in
6124 // CheckPointerTypesForAssignment. However, that would require a
6125 // bit of refactoring (so that the second argument is an
6126 // expression, rather than a type), which should be done as part
6127 // of a larger effort to fix CheckPointerTypesForAssignment for
6128 // C++ semantics.
6129 if (getLangOptions().CPlusPlus &&
6130 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
6131 return false;
Chris Lattner5cf216b2008-01-04 18:04:52 +00006132 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
6133 break;
Steve Naroff1c7d0672008-09-04 15:10:53 +00006134 case IntToBlockPointer:
6135 DiagKind = diag::err_int_to_block_pointer;
6136 break;
6137 case IncompatibleBlockPointer:
Mike Stump25efa102009-04-21 22:51:42 +00006138 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
Steve Naroff1c7d0672008-09-04 15:10:53 +00006139 break;
Steve Naroff39579072008-10-14 22:18:38 +00006140 case IncompatibleObjCQualifiedId:
Mike Stumpeed9cac2009-02-19 03:04:26 +00006141 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
Steve Naroff39579072008-10-14 22:18:38 +00006142 // it can give a more specific diagnostic.
6143 DiagKind = diag::warn_incompatible_qualified_id;
6144 break;
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00006145 case IncompatibleVectors:
6146 DiagKind = diag::warn_incompatible_vectors;
6147 break;
Chris Lattner5cf216b2008-01-04 18:04:52 +00006148 case Incompatible:
6149 DiagKind = diag::err_typecheck_convert_incompatible;
6150 isInvalid = true;
6151 break;
6152 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00006153
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00006154 Diag(Loc, DiagKind) << DstType << SrcType << Flavor
6155 << SrcExpr->getSourceRange();
Chris Lattner5cf216b2008-01-04 18:04:52 +00006156 return isInvalid;
6157}
Anders Carlssone21555e2008-11-30 19:50:32 +00006158
Chris Lattner3bf68932009-04-25 21:59:05 +00006159bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){
Eli Friedman3b5ccca2009-04-25 22:26:58 +00006160 llvm::APSInt ICEResult;
6161 if (E->isIntegerConstantExpr(ICEResult, Context)) {
6162 if (Result)
6163 *Result = ICEResult;
6164 return false;
6165 }
6166
Anders Carlssone21555e2008-11-30 19:50:32 +00006167 Expr::EvalResult EvalResult;
6168
Mike Stumpeed9cac2009-02-19 03:04:26 +00006169 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() ||
Anders Carlssone21555e2008-11-30 19:50:32 +00006170 EvalResult.HasSideEffects) {
6171 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange();
6172
6173 if (EvalResult.Diag) {
6174 // We only show the note if it's not the usual "invalid subexpression"
6175 // or if it's actually in a subexpression.
6176 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice ||
6177 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens())
6178 Diag(EvalResult.DiagLoc, EvalResult.Diag);
6179 }
Mike Stumpeed9cac2009-02-19 03:04:26 +00006180
Anders Carlssone21555e2008-11-30 19:50:32 +00006181 return true;
6182 }
6183
Eli Friedman3b5ccca2009-04-25 22:26:58 +00006184 Diag(E->getExprLoc(), diag::ext_expr_not_ice) <<
6185 E->getSourceRange();
Anders Carlssone21555e2008-11-30 19:50:32 +00006186
Eli Friedman3b5ccca2009-04-25 22:26:58 +00006187 if (EvalResult.Diag &&
6188 Diags.getDiagnosticLevel(diag::ext_expr_not_ice) != Diagnostic::Ignored)
6189 Diag(EvalResult.DiagLoc, EvalResult.Diag);
Mike Stumpeed9cac2009-02-19 03:04:26 +00006190
Anders Carlssone21555e2008-11-30 19:50:32 +00006191 if (Result)
6192 *Result = EvalResult.Val.getInt();
6193 return false;
6194}
Douglas Gregore0762c92009-06-19 23:52:42 +00006195
Mike Stump1eb44332009-09-09 15:08:12 +00006196Sema::ExpressionEvaluationContext
6197Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) {
Douglas Gregorac7610d2009-06-22 20:57:11 +00006198 // Introduce a new set of potentially referenced declarations to the stack.
6199 if (NewContext == PotentiallyPotentiallyEvaluated)
6200 PotentiallyReferencedDeclStack.push_back(PotentiallyReferencedDecls());
Mike Stump1eb44332009-09-09 15:08:12 +00006201
Douglas Gregorac7610d2009-06-22 20:57:11 +00006202 std::swap(ExprEvalContext, NewContext);
6203 return NewContext;
6204}
6205
Mike Stump1eb44332009-09-09 15:08:12 +00006206void
Douglas Gregorac7610d2009-06-22 20:57:11 +00006207Sema::PopExpressionEvaluationContext(ExpressionEvaluationContext OldContext,
6208 ExpressionEvaluationContext NewContext) {
6209 ExprEvalContext = NewContext;
6210
6211 if (OldContext == PotentiallyPotentiallyEvaluated) {
6212 // Mark any remaining declarations in the current position of the stack
6213 // as "referenced". If they were not meant to be referenced, semantic
6214 // analysis would have eliminated them (e.g., in ActOnCXXTypeId).
6215 PotentiallyReferencedDecls RemainingDecls;
6216 RemainingDecls.swap(PotentiallyReferencedDeclStack.back());
6217 PotentiallyReferencedDeclStack.pop_back();
Mike Stump1eb44332009-09-09 15:08:12 +00006218
Douglas Gregorac7610d2009-06-22 20:57:11 +00006219 for (PotentiallyReferencedDecls::iterator I = RemainingDecls.begin(),
6220 IEnd = RemainingDecls.end();
6221 I != IEnd; ++I)
6222 MarkDeclarationReferenced(I->first, I->second);
6223 }
6224}
Douglas Gregore0762c92009-06-19 23:52:42 +00006225
6226/// \brief Note that the given declaration was referenced in the source code.
6227///
6228/// This routine should be invoke whenever a given declaration is referenced
6229/// in the source code, and where that reference occurred. If this declaration
6230/// reference means that the the declaration is used (C++ [basic.def.odr]p2,
6231/// C99 6.9p3), then the declaration will be marked as used.
6232///
6233/// \param Loc the location where the declaration was referenced.
6234///
6235/// \param D the declaration that has been referenced by the source code.
6236void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) {
6237 assert(D && "No declaration?");
Mike Stump1eb44332009-09-09 15:08:12 +00006238
Douglas Gregord7f37bf2009-06-22 23:06:13 +00006239 if (D->isUsed())
6240 return;
Mike Stump1eb44332009-09-09 15:08:12 +00006241
Douglas Gregorb5352cf2009-10-08 21:35:42 +00006242 // Mark a parameter or variable declaration "used", regardless of whether we're in a
6243 // template or not. The reason for this is that unevaluated expressions
6244 // (e.g. (void)sizeof()) constitute a use for warning purposes (-Wunused-variables and
6245 // -Wunused-parameters)
6246 if (isa<ParmVarDecl>(D) ||
6247 (isa<VarDecl>(D) && D->getDeclContext()->isFunctionOrMethod()))
Douglas Gregore0762c92009-06-19 23:52:42 +00006248 D->setUsed(true);
Mike Stump1eb44332009-09-09 15:08:12 +00006249
Douglas Gregore0762c92009-06-19 23:52:42 +00006250 // Do not mark anything as "used" within a dependent context; wait for
6251 // an instantiation.
6252 if (CurContext->isDependentContext())
6253 return;
Mike Stump1eb44332009-09-09 15:08:12 +00006254
Douglas Gregorac7610d2009-06-22 20:57:11 +00006255 switch (ExprEvalContext) {
6256 case Unevaluated:
6257 // We are in an expression that is not potentially evaluated; do nothing.
6258 return;
Mike Stump1eb44332009-09-09 15:08:12 +00006259
Douglas Gregorac7610d2009-06-22 20:57:11 +00006260 case PotentiallyEvaluated:
6261 // We are in a potentially-evaluated expression, so this declaration is
6262 // "used"; handle this below.
6263 break;
Mike Stump1eb44332009-09-09 15:08:12 +00006264
Douglas Gregorac7610d2009-06-22 20:57:11 +00006265 case PotentiallyPotentiallyEvaluated:
6266 // We are in an expression that may be potentially evaluated; queue this
6267 // declaration reference until we know whether the expression is
6268 // potentially evaluated.
6269 PotentiallyReferencedDeclStack.back().push_back(std::make_pair(Loc, D));
6270 return;
6271 }
Mike Stump1eb44332009-09-09 15:08:12 +00006272
Douglas Gregore0762c92009-06-19 23:52:42 +00006273 // Note that this declaration has been used.
Fariborz Jahanianb7f4cc02009-06-22 17:30:33 +00006274 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00006275 unsigned TypeQuals;
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00006276 if (Constructor->isImplicit() && Constructor->isDefaultConstructor()) {
6277 if (!Constructor->isUsed())
6278 DefineImplicitDefaultConstructor(Loc, Constructor);
Mike Stump1eb44332009-09-09 15:08:12 +00006279 } else if (Constructor->isImplicit() &&
Mike Stumpac5fc7c2009-08-04 21:02:39 +00006280 Constructor->isCopyConstructor(Context, TypeQuals)) {
Fariborz Jahanian485f0872009-06-22 23:34:40 +00006281 if (!Constructor->isUsed())
6282 DefineImplicitCopyConstructor(Loc, Constructor, TypeQuals);
6283 }
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00006284 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
6285 if (Destructor->isImplicit() && !Destructor->isUsed())
6286 DefineImplicitDestructor(Loc, Destructor);
Mike Stump1eb44332009-09-09 15:08:12 +00006287
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00006288 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) {
6289 if (MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
6290 MethodDecl->getOverloadedOperator() == OO_Equal) {
6291 if (!MethodDecl->isUsed())
6292 DefineImplicitOverloadedAssign(Loc, MethodDecl);
6293 }
6294 }
Fariborz Jahanianf5ed9e02009-06-24 22:09:44 +00006295 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
Mike Stump1eb44332009-09-09 15:08:12 +00006296 // Implicit instantiation of function templates and member functions of
Douglas Gregor1637be72009-06-26 00:10:03 +00006297 // class templates.
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00006298 if (!Function->getBody() &&
6299 Function->getTemplateSpecializationKind()
6300 == TSK_ImplicitInstantiation) {
6301 bool AlreadyInstantiated = false;
6302 if (FunctionTemplateSpecializationInfo *SpecInfo
6303 = Function->getTemplateSpecializationInfo()) {
6304 if (SpecInfo->getPointOfInstantiation().isInvalid())
6305 SpecInfo->setPointOfInstantiation(Loc);
6306 else
6307 AlreadyInstantiated = true;
6308 } else if (MemberSpecializationInfo *MSInfo
6309 = Function->getMemberSpecializationInfo()) {
6310 if (MSInfo->getPointOfInstantiation().isInvalid())
6311 MSInfo->setPointOfInstantiation(Loc);
6312 else
6313 AlreadyInstantiated = true;
6314 }
6315
6316 if (!AlreadyInstantiated)
6317 PendingImplicitInstantiations.push_back(std::make_pair(Function, Loc));
6318 }
6319
Douglas Gregore0762c92009-06-19 23:52:42 +00006320 // FIXME: keep track of references to static functions
Douglas Gregore0762c92009-06-19 23:52:42 +00006321 Function->setUsed(true);
6322 return;
Douglas Gregord7f37bf2009-06-22 23:06:13 +00006323 }
Mike Stump1eb44332009-09-09 15:08:12 +00006324
Douglas Gregore0762c92009-06-19 23:52:42 +00006325 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
Douglas Gregor7caa6822009-07-24 20:34:43 +00006326 // Implicit instantiation of static data members of class templates.
Mike Stump1eb44332009-09-09 15:08:12 +00006327 if (Var->isStaticDataMember() &&
Douglas Gregorb3ae4fc2009-10-12 20:18:28 +00006328 Var->getInstantiatedFromStaticDataMember()) {
6329 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
6330 assert(MSInfo && "Missing member specialization information?");
6331 if (MSInfo->getPointOfInstantiation().isInvalid() &&
6332 MSInfo->getTemplateSpecializationKind()== TSK_ImplicitInstantiation) {
6333 MSInfo->setPointOfInstantiation(Loc);
6334 PendingImplicitInstantiations.push_back(std::make_pair(Var, Loc));
6335 }
6336 }
Mike Stump1eb44332009-09-09 15:08:12 +00006337
Douglas Gregore0762c92009-06-19 23:52:42 +00006338 // FIXME: keep track of references to static data?
Douglas Gregor7caa6822009-07-24 20:34:43 +00006339
Douglas Gregore0762c92009-06-19 23:52:42 +00006340 D->setUsed(true);
Douglas Gregor7caa6822009-07-24 20:34:43 +00006341 return;
Sam Weinigcce6ebc2009-09-11 03:29:30 +00006342 }
Douglas Gregore0762c92009-06-19 23:52:42 +00006343}
Anders Carlsson8c8d9192009-10-09 23:51:55 +00006344
6345bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
6346 CallExpr *CE, FunctionDecl *FD) {
6347 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
6348 return false;
6349
6350 PartialDiagnostic Note =
6351 FD ? PDiag(diag::note_function_with_incomplete_return_type_declared_here)
6352 << FD->getDeclName() : PDiag();
6353 SourceLocation NoteLoc = FD ? FD->getLocation() : SourceLocation();
6354
6355 if (RequireCompleteType(Loc, ReturnType,
6356 FD ?
6357 PDiag(diag::err_call_function_incomplete_return)
6358 << CE->getSourceRange() << FD->getDeclName() :
6359 PDiag(diag::err_call_incomplete_return)
6360 << CE->getSourceRange(),
6361 std::make_pair(NoteLoc, Note)))
6362 return true;
6363
6364 return false;
6365}
6366
John McCall5a881bb2009-10-12 21:59:07 +00006367// Diagnose the common s/=/==/ typo. Note that adding parentheses
6368// will prevent this condition from triggering, which is what we want.
6369void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
6370 SourceLocation Loc;
6371
6372 if (isa<BinaryOperator>(E)) {
6373 BinaryOperator *Op = cast<BinaryOperator>(E);
6374 if (Op->getOpcode() != BinaryOperator::Assign)
6375 return;
6376
6377 Loc = Op->getOperatorLoc();
6378 } else if (isa<CXXOperatorCallExpr>(E)) {
6379 CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(E);
6380 if (Op->getOperator() != OO_Equal)
6381 return;
6382
6383 Loc = Op->getOperatorLoc();
6384 } else {
6385 // Not an assignment.
6386 return;
6387 }
6388
John McCall5a881bb2009-10-12 21:59:07 +00006389 SourceLocation Open = E->getSourceRange().getBegin();
John McCall2d152152009-10-12 22:25:59 +00006390 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd());
John McCall5a881bb2009-10-12 21:59:07 +00006391
6392 Diag(Loc, diag::warn_condition_is_assignment)
6393 << E->getSourceRange()
6394 << CodeModificationHint::CreateInsertion(Open, "(")
6395 << CodeModificationHint::CreateInsertion(Close, ")");
6396}
6397
6398bool Sema::CheckBooleanCondition(Expr *&E, SourceLocation Loc) {
6399 DiagnoseAssignmentAsCondition(E);
6400
6401 if (!E->isTypeDependent()) {
6402 DefaultFunctionArrayConversion(E);
6403
6404 QualType T = E->getType();
6405
6406 if (getLangOptions().CPlusPlus) {
6407 if (CheckCXXBooleanCondition(E)) // C++ 6.4p4
6408 return true;
6409 } else if (!T->isScalarType()) { // C99 6.8.4.1p1
6410 Diag(Loc, diag::err_typecheck_statement_requires_scalar)
6411 << T << E->getSourceRange();
6412 return true;
6413 }
6414 }
6415
6416 return false;
6417}